diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index fd7027c30ebe..c26c6403676b 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -352,6 +352,7 @@ endif()
 
 if(ARROW_ENGINE)
   set(ARROW_COMPUTE ON)
+  set(ARROW_DATASET ON)
 endif()
 
 if(ARROW_SKYHOOK)
diff --git a/cpp/build-support/lint_cpp_cli.py b/cpp/build-support/lint_cpp_cli.py
index a0eb8f0efe6d..0dd9b5b91285 100755
--- a/cpp/build-support/lint_cpp_cli.py
+++ b/cpp/build-support/lint_cpp_cli.py
@@ -89,7 +89,8 @@ def lint_file(path):
     jni/
     test
     internal
-    _generated''')
+    _generated
+    generated/substrait/''')
 
 
 def lint_files():
diff --git a/cpp/build-support/lint_exclusions.txt b/cpp/build-support/lint_exclusions.txt
index 73cbd884f44e..46c9532266de 100644
--- a/cpp/build-support/lint_exclusions.txt
+++ b/cpp/build-support/lint_exclusions.txt
@@ -1,4 +1,5 @@
 *_generated*
+*generated/substrait/*.pb.*
 *.grpc.fb.*
 *arrowExports.cpp*
 *parquet_constants.*
diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake
index 0a43ec18f609..8a7f31041d70 100644
--- a/cpp/cmake_modules/DefineOptions.cmake
+++ b/cpp/cmake_modules/DefineOptions.cmake
@@ -225,7 +225,7 @@ if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
 
   define_option(ARROW_DATASET "Build the Arrow Dataset Modules" OFF)
 
-  define_option(ARROW_ENGINE "Build the Arrow Execution Engine" OFF)
+  define_option(ARROW_ENGINE "Build the Arrow Query Engine Module" OFF)
 
   define_option(ARROW_FILESYSTEM "Build the Arrow Filesystem Layer" OFF)
 
@@ -478,6 +478,13 @@ advised that if this is enabled 'install' will fail silently on components;\
 that have not been built"
                 OFF)
 
+  set(ARROW_SUBSTRAIT_REPO_AND_TAG_DEFAULT
+      "https://github.com/substrait-io/substrait e1b4c04a1b518912f4c4065b16a1b2c0ac8e14cf"
+  )
+  define_option_string(ARROW_SUBSTRAIT_REPO_AND_TAG
+                       "Custom 'repository_url tag' for generating substrait accessors"
+                       "${ARROW_SUBSTRAIT_REPO_AND_TAG_DEFAULT}")
+
   option(ARROW_BUILD_CONFIG_SUMMARY_JSON "Summarize build configuration in a JSON file"
          ON)
 endif()
diff --git a/cpp/cmake_modules/FindArrowEngine.cmake b/cpp/cmake_modules/FindArrowEngine.cmake
new file mode 100644
index 000000000000..3ee09e0de3d9
--- /dev/null
+++ b/cpp/cmake_modules/FindArrowEngine.cmake
@@ -0,0 +1,88 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# - Find Arrow Engine (arrow/engine/api.h, libarrow_engine.a, libarrow_engine.so)
+#
+# This module requires Arrow from which it uses
+#  arrow_find_package()
+#
+# This module defines
+#  ARROW_ENGINE_FOUND, whether Arrow Engine has been found
+#  ARROW_ENGINE_IMPORT_LIB,
+#    path to libarrow_engine's import library (Windows only)
+#  ARROW_ENGINE_INCLUDE_DIR, directory containing headers
+#  ARROW_ENGINE_LIB_DIR, directory containing Arrow Engine libraries
+#  ARROW_ENGINE_SHARED_LIB, path to libarrow_engine's shared library
+#  ARROW_ENGINE_STATIC_LIB, path to libarrow_engine.a
+
+if(DEFINED ARROW_ENGINE_FOUND)
+  return()
+endif()
+
+set(find_package_arguments)
+if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION)
+  list(APPEND find_package_arguments "${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION}")
+endif()
+if(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED)
+  list(APPEND find_package_arguments REQUIRED)
+endif()
+if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+  list(APPEND find_package_arguments QUIET)
+endif()
+find_package(Arrow ${find_package_arguments})
+find_package(Parquet ${find_package_arguments})
+
+if(ARROW_FOUND AND PARQUET_FOUND)
+  arrow_find_package(ARROW_ENGINE
+                     "${ARROW_HOME}"
+                     arrow_engine
+                     arrow/engine/api.h
+                     ArrowEngine
+                     arrow-engine)
+  if(NOT ARROW_ENGINE_VERSION)
+    set(ARROW_ENGINE_VERSION "${ARROW_VERSION}")
+  endif()
+endif()
+
+if("${ARROW_ENGINE_VERSION}" VERSION_EQUAL "${ARROW_VERSION}")
+  set(ARROW_ENGINE_VERSION_MATCH TRUE)
+else()
+  set(ARROW_ENGINE_VERSION_MATCH FALSE)
+endif()
+
+mark_as_advanced(ARROW_ENGINE_IMPORT_LIB
+                 ARROW_ENGINE_INCLUDE_DIR
+                 ARROW_ENGINE_LIBS
+                 ARROW_ENGINE_LIB_DIR
+                 ARROW_ENGINE_SHARED_IMP_LIB
+                 ARROW_ENGINE_SHARED_LIB
+                 ARROW_ENGINE_STATIC_LIB
+                 ARROW_ENGINE_VERSION
+                 ARROW_ENGINE_VERSION_MATCH)
+
+find_package_handle_standard_args(
+  ArrowEngine
+  REQUIRED_VARS ARROW_ENGINE_INCLUDE_DIR ARROW_ENGINE_LIB_DIR ARROW_ENGINE_VERSION_MATCH
+  VERSION_VAR ARROW_ENGINE_VERSION)
+set(ARROW_ENGINE_FOUND ${ArrowEngine_FOUND})
+
+if(ArrowEngine_FOUND AND NOT ArrowEngine_FIND_QUIETLY)
+  message(STATUS "Found the Arrow Engine by ${ARROW_ENGINE_FIND_APPROACH}")
+  message(STATUS "Found the Arrow Engine shared library: ${ARROW_ENGINE_SHARED_LIB}")
+  message(STATUS "Found the Arrow Engine import library: ${ARROW_ENGINE_IMPORT_LIB}")
+  message(STATUS "Found the Arrow Engine static library: ${ARROW_ENGINE_STATIC_LIB}")
+endif()
diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index d85e511c1e7f..a391dc887243 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -309,7 +309,8 @@ endif()
 
 if(ARROW_ORC
    OR ARROW_FLIGHT
-   OR ARROW_GANDIVA)
+   OR ARROW_GANDIVA
+   OR ARROW_ENGINE)
   set(ARROW_WITH_PROTOBUF ON)
 endif()
 
diff --git a/cpp/examples/arrow/CMakeLists.txt b/cpp/examples/arrow/CMakeLists.txt
index e46cc7a6fe58..838d7b982c9b 100644
--- a/cpp/examples/arrow/CMakeLists.txt
+++ b/cpp/examples/arrow/CMakeLists.txt
@@ -21,6 +21,10 @@ if(ARROW_COMPUTE)
   add_arrow_example(compute_register_example)
 endif()
 
+if(ARROW_ENGINE)
+  add_arrow_example(engine_substrait_consumption EXTRA_LINK_LIBS arrow_engine_shared)
+endif()
+
 if(ARROW_COMPUTE AND ARROW_CSV)
   add_arrow_example(compute_and_write_csv_example)
 endif()
diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc
new file mode 100644
index 000000000000..1dfaff1b67d4
--- /dev/null
+++ b/cpp/examples/arrow/engine_substrait_consumption.cc
@@ -0,0 +1,187 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <arrow/api.h>
+#include <arrow/compute/api.h>
+#include <arrow/compute/exec/options.h>
+#include <arrow/engine/substrait/serde.h>
+
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+#include <vector>
+
+namespace eng = ::arrow::engine;
+namespace cp = ::arrow::compute;
+
+#define ABORT_ON_FAILURE(expr)                     \
+  do {                                             \
+    arrow::Status status_ = (expr);                \
+    if (!status_.ok()) {                           \
+      std::cerr << status_.message() << std::endl; \
+      abort();                                     \
+    }                                              \
+  } while (0);
+
+arrow::Future<std::shared_ptr<arrow::Buffer>> GetSubstraitFromServer();
+
+class IgnoringConsumer : public cp::SinkNodeConsumer {
+ public:
+  explicit IgnoringConsumer(size_t tag) : tag_{tag} {}
+
+  arrow::Status Consume(cp::ExecBatch batch) override {
+    // Consume a batch of data
+    // (just print its row count to stdout)
+    std::cout << "-" << tag_ << " consumed " << batch.length << " rows" << std::endl;
+    return arrow::Status::OK();
+  }
+
+  arrow::Future<> Finish() override {
+    // Signal to the consumer that the last batch has been delivered
+    // (we don't do any real work in this consumer so mark it finished immediately)
+    //
+    // The returned future should only finish when all outstanding tasks have completed
+    // (after this method is called Consume is guaranteed not to be called again)
+    std::cout << "-" << tag_ << " finished" << std::endl;
+    return arrow::Future<>::MakeFinished();
+  }
+
+ private:
+  size_t tag_;
+};
+
+int main(int argc, char** argv) {
+  // Plans arrive at the consumer serialized in a substrait-formatted Buffer
+  auto maybe_serialized_plan = GetSubstraitFromServer().result();
+  ABORT_ON_FAILURE(maybe_serialized_plan.status());
+  std::shared_ptr<arrow::Buffer> serialized_plan =
+      std::move(maybe_serialized_plan).ValueOrDie();
+
+  // Print the received plan to stdout as JSON
+  arrow::Result<std::string> maybe_plan_json =
+      eng::internal::SubstraitToJSON("Plan", *serialized_plan);
+  ABORT_ON_FAILURE(maybe_plan_json.status());
+  std::cout << std::string('#', 50) << " received substrait::Plan:" << std::endl;
+  std::cout << maybe_plan_json.ValueOrDie() << std::endl;
+
+  // Deserializing a plan requires a factory for consumers: each time a sink node is
+  // deserialized, a consumer is constructed into which its batches will be piped.
+  std::vector<std::shared_ptr<cp::SinkNodeConsumer>> consumers;
+  std::function<std::shared_ptr<cp::SinkNodeConsumer>()> consumer_factory = [&] {
+    // All batches produced by the plan will be fed into IgnoringConsumers:
+    auto tag = consumers.size();
+    consumers.emplace_back(new IgnoringConsumer{tag});
+    return consumers.back();
+  };
+
+  // NOTE Although most of the Deserialize functions require a const ExtensionSet& to
+  // resolve extension references, a Plan is what we use to construct that ExtensionSet.
+  // (It should be an optional output later.) In particular, it does not need to be kept
+  // alive nor does the serialized plan- none of the arrow:: objects in the output will
+  // contain references to memory owned by either.
+  auto maybe_decls = eng::DeserializePlan(*serialized_plan, consumer_factory);
+  ABORT_ON_FAILURE(maybe_decls.status());
+  std::vector<cp::Declaration> decls = std::move(maybe_decls).ValueOrDie();
+
+  // It's safe to drop the serialized plan; we don't leave references to its memory
+  serialized_plan.reset();
+
+  // Construct an empty plan (note: configure Function registry and ThreadPool here)
+  auto maybe_plan = cp::ExecPlan::Make();
+  ABORT_ON_FAILURE(maybe_plan.status());
+  std::shared_ptr<cp::ExecPlan> plan = std::move(maybe_plan).ValueOrDie();
+
+  for (const cp::Declaration& decl : decls) {
+    // Add decl to plan (note: configure ExecNode registry here)
+    ABORT_ON_FAILURE(decl.AddToPlan(plan.get()).status());
+  }
+
+  // Validate the plan and print it to stdout
+  ABORT_ON_FAILURE(plan->Validate());
+  std::cout << std::string('#', 50) << " produced arrow::ExecPlan:" << std::endl;
+  std::cout << plan->ToString() << std::endl;
+
+  // Start the plan...
+  std::cout << std::string('#', 50) << " consuming batches:" << std::endl;
+  ABORT_ON_FAILURE(plan->StartProducing());
+
+  // ... and wait for it to finish
+  ABORT_ON_FAILURE(plan->finished().status());
+  return EXIT_SUCCESS;
+}
+
+arrow::Future<std::shared_ptr<arrow::Buffer>> GetSubstraitFromServer() {
+  // Emulate server interaction by parsing hard coded JSON
+  return eng::internal::SubstraitFromJSON("Plan", R"({
+    "relations": [
+      {"rel": {
+        "read": {
+          "base_schema": {
+            "struct": {
+              "types": [ {"i64": {}}, {"bool": {}} ]
+            },
+            "names": ["i", "b"]
+          },
+          "filter": {
+            "selection": {
+              "directReference": {
+                "structField": {
+                  "field": 1
+                }
+              }
+            }
+          },
+          "local_files": {
+            "items": [
+              {
+                "uri_file": "file:///tmp/dat1.parquet",
+                "format": "FILE_FORMAT_PARQUET"
+              },
+              {
+                "uri_file": "file:///tmp/dat2.parquet",
+                "format": "FILE_FORMAT_PARQUET"
+              }
+            ]
+          }
+        }
+      }}
+    ],
+    "extension_uris": [
+      {
+        "extension_uri_anchor": 7,
+        "uri": "https://github.com/apache/arrow/blob/master/format/substrait/extension_types.yaml"
+      }
+    ],
+    "extensions": [
+      {"extension_type": {
+        "extension_uri_reference": 7,
+        "type_anchor": 42,
+        "name": "null"
+      }},
+      {"extension_type_variation": {
+        "extension_uri_reference": 7,
+        "type_variation_anchor": 23,
+        "name": "u8"
+      }},
+      {"extension_function": {
+        "extension_uri_reference": 7,
+        "function_anchor": 42,
+        "name": "add"
+      }}
+    ]
+  })");
+}
diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index b984bc10425a..e44213451893 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -722,6 +722,10 @@ if(ARROW_COMPUTE)
   add_subdirectory(compute)
 endif()
 
+if(ARROW_ENGINE)
+  add_subdirectory(engine)
+endif()
+
 if(ARROW_CUDA)
   add_subdirectory(gpu)
 endif()
diff --git a/cpp/src/arrow/array/array_base.cc b/cpp/src/arrow/array/array_base.cc
index c31a7b724833..11b6b1630c5f 100644
--- a/cpp/src/arrow/array/array_base.cc
+++ b/cpp/src/arrow/array/array_base.cc
@@ -282,6 +282,8 @@ std::string Array::ToString() const {
   return ss.str();
 }
 
+void PrintTo(const Array& x, std::ostream* os) { *os << x.ToString(); }
+
 Result<std::shared_ptr<Array>> Array::View(
     const std::shared_ptr<DataType>& out_type) const {
   ARROW_ASSIGN_OR_RAISE(std::shared_ptr<ArrayData> result,
diff --git a/cpp/src/arrow/array/array_base.h b/cpp/src/arrow/array/array_base.h
index b6b769cf0333..c17daad48fab 100644
--- a/cpp/src/arrow/array/array_base.h
+++ b/cpp/src/arrow/array/array_base.h
@@ -187,10 +187,11 @@ class ARROW_EXPORT Array {
   Status ValidateFull() const;
 
  protected:
-  Array() : null_bitmap_data_(NULLPTR) {}
+  Array() = default;
+  ARROW_DEFAULT_MOVE_AND_ASSIGN(Array);
 
   std::shared_ptr<ArrayData> data_;
-  const uint8_t* null_bitmap_data_;
+  const uint8_t* null_bitmap_data_ = NULLPTR;
 
   /// Protected method for constructors
   void SetData(const std::shared_ptr<ArrayData>& data) {
@@ -204,6 +205,8 @@ class ARROW_EXPORT Array {
 
  private:
   ARROW_DISALLOW_COPY_AND_ASSIGN(Array);
+
+  ARROW_EXPORT friend void PrintTo(const Array& x, std::ostream* os);
 };
 
 static inline std::ostream& operator<<(std::ostream& os, const Array& x) {
diff --git a/cpp/src/arrow/array/builder_base.h b/cpp/src/arrow/array/builder_base.h
index a513bf0f4ab7..4b0e0147ceab 100644
--- a/cpp/src/arrow/array/builder_base.h
+++ b/cpp/src/arrow/array/builder_base.h
@@ -28,6 +28,7 @@
 #include "arrow/array/array_primitive.h"
 #include "arrow/buffer.h"
 #include "arrow/buffer_builder.h"
+#include "arrow/result.h"
 #include "arrow/status.h"
 #include "arrow/type_fwd.h"
 #include "arrow/util/macros.h"
@@ -286,6 +287,13 @@ ARROW_EXPORT
 Status MakeBuilder(MemoryPool* pool, const std::shared_ptr<DataType>& type,
                    std::unique_ptr<ArrayBuilder>* out);
 
+inline Result<std::unique_ptr<ArrayBuilder>> MakeBuilder(
+    const std::shared_ptr<DataType>& type, MemoryPool* pool = default_memory_pool()) {
+  std::unique_ptr<ArrayBuilder> out;
+  ARROW_RETURN_NOT_OK(MakeBuilder(pool, type, &out));
+  return std::move(out);
+}
+
 /// \brief Construct an empty ArrayBuilder corresponding to the data
 /// type, where any top-level or nested dictionary builders return the
 /// exact index type specified by the type.
@@ -293,6 +301,13 @@ ARROW_EXPORT
 Status MakeBuilderExactIndex(MemoryPool* pool, const std::shared_ptr<DataType>& type,
                              std::unique_ptr<ArrayBuilder>* out);
 
+inline Result<std::unique_ptr<ArrayBuilder>> MakeBuilderExactIndex(
+    const std::shared_ptr<DataType>& type, MemoryPool* pool = default_memory_pool()) {
+  std::unique_ptr<ArrayBuilder> out;
+  ARROW_RETURN_NOT_OK(MakeBuilderExactIndex(pool, type, &out));
+  return std::move(out);
+}
+
 /// \brief Construct an empty DictionaryBuilder initialized optionally
 /// with a pre-existing dictionary
 /// \param[in] pool the MemoryPool to use for allocations
@@ -304,4 +319,12 @@ Status MakeDictionaryBuilder(MemoryPool* pool, const std::shared_ptr<DataType>&
                              const std::shared_ptr<Array>& dictionary,
                              std::unique_ptr<ArrayBuilder>* out);
 
+inline Result<std::unique_ptr<ArrayBuilder>> MakeDictionaryBuilder(
+    const std::shared_ptr<DataType>& type, const std::shared_ptr<Array>& dictionary,
+    MemoryPool* pool = default_memory_pool()) {
+  std::unique_ptr<ArrayBuilder> out;
+  ARROW_RETURN_NOT_OK(MakeDictionaryBuilder(pool, type, dictionary, &out));
+  return std::move(out);
+}
+
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/exec/expression_internal.h b/cpp/src/arrow/compute/exec/expression_internal.h
index dc38924d9325..f8c686d2c814 100644
--- a/cpp/src/arrow/compute/exec/expression_internal.h
+++ b/cpp/src/arrow/compute/exec/expression_internal.h
@@ -29,9 +29,6 @@
 #include "arrow/util/logging.h"
 
 namespace arrow {
-
-using internal::checked_cast;
-
 namespace compute {
 
 struct KnownFieldValues {
@@ -213,7 +210,7 @@ struct Comparison {
 
 inline const compute::CastOptions* GetCastOptions(const Expression::Call& call) {
   if (call.function_name != "cast") return nullptr;
-  return checked_cast<const compute::CastOptions*>(call.options.get());
+  return ::arrow::internal::checked_cast<const compute::CastOptions*>(call.options.get());
 }
 
 inline bool IsSetLookup(const std::string& function) {
@@ -223,7 +220,8 @@ inline bool IsSetLookup(const std::string& function) {
 inline const compute::MakeStructOptions* GetMakeStructOptions(
     const Expression::Call& call) {
   if (call.function_name != "make_struct") return nullptr;
-  return checked_cast<const compute::MakeStructOptions*>(call.options.get());
+  return ::arrow::internal::checked_cast<const compute::MakeStructOptions*>(
+      call.options.get());
 }
 
 /// A helper for unboxing an Expression composed of associative function calls.
@@ -281,7 +279,8 @@ inline Result<std::shared_ptr<compute::Function>> GetFunction(
     return exec_context->func_registry()->GetFunction(call.function_name);
   }
   // XXX this special case is strange; why not make "cast" a ScalarFunction?
-  const auto& to_type = checked_cast<const compute::CastOptions&>(*call.options).to_type;
+  const auto& to_type =
+      ::arrow::internal::checked_cast<const compute::CastOptions&>(*call.options).to_type;
   return compute::GetCastFunction(to_type);
 }
 
diff --git a/cpp/src/arrow/csv/column_decoder_test.cc b/cpp/src/arrow/csv/column_decoder_test.cc
index c8b96e046963..ebac7a3da2fc 100644
--- a/cpp/src/arrow/csv/column_decoder_test.cc
+++ b/cpp/src/arrow/csv/column_decoder_test.cc
@@ -22,6 +22,7 @@
 
 #include <gtest/gtest.h>
 
+#include "arrow/array/array_base.h"
 #include "arrow/csv/column_decoder.h"
 #include "arrow/csv/options.h"
 #include "arrow/csv/test_common.h"
diff --git a/cpp/src/arrow/datum.h b/cpp/src/arrow/datum.h
index 514b4247316e..45e0d682fa9a 100644
--- a/cpp/src/arrow/datum.h
+++ b/cpp/src/arrow/datum.h
@@ -153,6 +153,13 @@ struct ARROW_EXPORT Datum {
       : Datum(std::shared_ptr<typename std::conditional<IsArray, Array, Scalar>::type>(
             value)) {}
 
+  // Cast from subtypes of Array or Scalar to Datum
+  template <typename T, bool IsArray = std::is_base_of<Array, T>::value,
+            bool IsScalar = std::is_base_of<Scalar, T>::value,
+            typename = enable_if_t<IsArray || IsScalar>>
+  Datum(T&& value)  // NOLINT implicit conversion
+      : Datum(std::make_shared<T>(std::move(value))) {}
+
   // Convenience constructors
   explicit Datum(bool value);
   explicit Datum(int8_t value);
diff --git a/cpp/src/arrow/engine/ArrowEngineConfig.cmake.in b/cpp/src/arrow/engine/ArrowEngineConfig.cmake.in
new file mode 100644
index 000000000000..8fafcda3864e
--- /dev/null
+++ b/cpp/src/arrow/engine/ArrowEngineConfig.cmake.in
@@ -0,0 +1,38 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# This config sets the following variables in your project::
+#
+#   ArrowEngine_FOUND - true if Arrow Engine found on the system
+#
+# This config sets the following targets in your project::
+#
+#   arrow_engine_shared - for linked as shared library if shared library is built
+#   arrow_engine_static - for linked as static library if static library is built
+
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+find_dependency(Arrow)
+find_dependency(ArrowDataset)
+find_dependency(Parquet)
+
+# Load targets only once. If we load targets multiple times, CMake reports
+# already existent target error.
+if(NOT (TARGET arrow_engine_shared OR TARGET arrow_engine_static))
+  include("${CMAKE_CURRENT_LIST_DIR}/ArrowEngineTargets.cmake")
+endif()
diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt
new file mode 100644
index 000000000000..8412edd197d1
--- /dev/null
+++ b/cpp/src/arrow/engine/CMakeLists.txt
@@ -0,0 +1,151 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+add_custom_target(arrow_engine)
+
+arrow_install_all_headers("arrow/engine")
+
+set(ARROW_ENGINE_LINK_LIBS ${ARROW_PROTOBUF_LIBPROTOBUF})
+
+#if(WIN32)
+#  list(APPEND ARROW_ENGINE_LINK_LIBS ws2_32.lib)
+#endif()
+
+set(ARROW_ENGINE_SRCS
+    substrait/expression_internal.cc
+    substrait/extension_set.cc
+    substrait/extension_types.cc
+    substrait/serde.cc
+    substrait/plan_internal.cc
+    substrait/relation_internal.cc
+    substrait/type_internal.cc)
+
+set(SUBSTRAIT_LOCAL_DIR "${CMAKE_CURRENT_BINARY_DIR}/substrait")
+set(SUBSTRAIT_GEN_DIR "${ARROW_SOURCE_DIR}/src/generated")
+set(SUBSTRAIT_PROTOS
+    capabilities
+    expression
+    extensions/extensions
+    function
+    parameterized_types
+    plan
+    relations
+    type
+    type_expressions)
+
+string(FIND "${ARROW_SUBSTRAIT_REPO_AND_TAG}" " " TAG_START)
+if(TAG_START EQUAL -1)
+  message(FATAL_ERROR "Cannot parse ARROW_SUBSTRAIT_REPO_AND_TAG='${ARROW_SUBSTRAIT_REPO_AND_TAG}'"
+  )
+endif()
+string(SUBSTRING "${ARROW_SUBSTRAIT_REPO_AND_TAG}" 0 ${TAG_START} ARROW_SUBSTRAIT_REPO)
+string(SUBSTRING "${ARROW_SUBSTRAIT_REPO_AND_TAG}" ${TAG_START} -1 ARROW_SUBSTRAIT_TAG)
+string(STRIP "${ARROW_SUBSTRAIT_TAG}" ARROW_SUBSTRAIT_TAG)
+
+externalproject_add(substrait_ep
+                    GIT_REPOSITORY "${ARROW_SUBSTRAIT_REPO}"
+                    GIT_TAG "${ARROW_SUBSTRAIT_TAG}"
+                    SOURCE_DIR "${SUBSTRAIT_LOCAL_DIR}"
+                    CONFIGURE_COMMAND ""
+                    BUILD_COMMAND ""
+                    INSTALL_COMMAND "")
+
+set(SUBSTRAIT_SUPPRESSED_WARNINGS)
+if(MSVC)
+  # Protobuf generated files trigger some spurious warnings on MSVC.
+
+  # Implicit conversion from uint64_t to uint32_t:
+  list(APPEND SUBSTRAIT_SUPPRESSED_WARNINGS "/wd4244")
+
+  # Missing dll-interface:
+  list(APPEND SUBSTRAIT_SUPPRESSED_WARNINGS "/wd4251")
+endif()
+
+set(SUBSTRAIT_PROTO_GEN_ALL)
+foreach(SUBSTRAIT_PROTO ${SUBSTRAIT_PROTOS})
+  set(SUBSTRAIT_PROTO_GEN "${SUBSTRAIT_GEN_DIR}/substrait/${SUBSTRAIT_PROTO}.pb")
+
+  foreach(EXT h cc)
+    set_source_files_properties("${SUBSTRAIT_PROTO_GEN}.${EXT}"
+                                PROPERTIES COMPILE_OPTIONS
+                                           "${SUBSTRAIT_SUPPRESSED_WARNINGS}"
+                                           GENERATED TRUE
+                                           SKIP_UNITY_BUILD_INCLUSION TRUE)
+    add_custom_command(OUTPUT "${SUBSTRAIT_PROTO_GEN}.${EXT}"
+                       COMMAND ${ARROW_PROTOBUF_PROTOC} "-I${SUBSTRAIT_LOCAL_DIR}/proto"
+                               "--cpp_out=${SUBSTRAIT_GEN_DIR}"
+                               "${SUBSTRAIT_LOCAL_DIR}/proto/substrait/${SUBSTRAIT_PROTO}.proto"
+                       DEPENDS ${PROTO_DEPENDS} substrait_ep)
+    list(APPEND SUBSTRAIT_PROTO_GEN_ALL "${SUBSTRAIT_PROTO_GEN}.${EXT}")
+  endforeach()
+
+  list(APPEND ARROW_ENGINE_SRCS "${SUBSTRAIT_PROTO_GEN}.cc")
+endforeach()
+
+add_custom_target(substrait_gen ALL DEPENDS ${SUBSTRAIT_PROTO_GEN_ALL})
+
+find_package(Git)
+add_custom_target(substrait_gen_verify
+                  COMMENT "Verifying that generated substrait accessors are consistent with \
+                           ARROW_SUBSTRAIT_REPO_AND_TAG='${ARROW_SUBSTRAIT_REPO_AND_TAG}'"
+                  COMMAND ${GIT_EXECUTABLE} diff --exit-code ${SUBSTRAIT_GEN_DIR}
+                  DEPENDS substrait_gen_clear
+                  DEPENDS substrait_gen)
+
+add_arrow_lib(arrow_engine
+              CMAKE_PACKAGE_NAME
+              ArrowEngine
+              PKG_CONFIG_NAME
+              arrow-engine
+              OUTPUTS
+              ARROW_ENGINE_LIBRARIES
+              SOURCES
+              ${ARROW_ENGINE_SRCS}
+              PRECOMPILED_HEADERS
+              "$<$<COMPILE_LANGUAGE:CXX>:arrow/engine/pch.h>"
+              SHARED_LINK_FLAGS
+              ${ARROW_VERSION_SCRIPT_FLAGS} # Defined in cpp/arrow/CMakeLists.txt
+              SHARED_LINK_LIBS
+              arrow_shared
+              arrow_dataset_shared
+              ${ARROW_ENGINE_LINK_LIBS}
+              STATIC_LINK_LIBS
+              arrow_static
+              arrow_dataset_static
+              ${ARROW_ENGINE_LINK_LIBS})
+
+foreach(LIB_TARGET ${ARROW_ENGINE_LIBRARIES})
+  target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_ENGINE_EXPORTING
+                                                   LIBPROTOBUF_EXPORTS)
+endforeach()
+
+set(ARROW_ENGINE_TEST_LINK_LIBS ${ARROW_ENGINE_LINK_lIBS} ${ARROW_TEST_LINK_LIBS})
+if(ARROW_TEST_LINKAGE STREQUAL "static")
+  list(APPEND ARROW_ENGINE_TEST_LINK_LIBS arrow_engine_static)
+else()
+  list(APPEND ARROW_ENGINE_TEST_LINK_LIBS arrow_engine_shared)
+endif()
+
+add_arrow_test(substrait_test
+               SOURCES
+               substrait/serde_test.cc
+               EXTRA_LINK_LIBS
+               ${ARROW_ENGINE_TEST_LINK_LIBS}
+               PREFIX
+               "arrow-engine"
+               LABELS
+               "arrow_engine")
diff --git a/cpp/src/arrow/engine/api.h b/cpp/src/arrow/engine/api.h
new file mode 100644
index 000000000000..de996e4d264b
--- /dev/null
+++ b/cpp/src/arrow/engine/api.h
@@ -0,0 +1,23 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// This API is EXPERIMENTAL.
+
+#pragma once
+
+#include "arrow/engine/substrait/extension_types.h"
+#include "arrow/engine/substrait/serde.h"
diff --git a/cpp/src/arrow/engine/arrow-engine.pc.in b/cpp/src/arrow/engine/arrow-engine.pc.in
new file mode 100644
index 000000000000..90fba82a8e92
--- /dev/null
+++ b/cpp/src/arrow/engine/arrow-engine.pc.in
@@ -0,0 +1,25 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: Apache Arrow Engine
+Description: Apache Arrow's Query Engine.
+Version: @ARROW_VERSION@
+Requires: arrow
+Libs: -L${libdir} -larrow_engine
diff --git a/cpp/src/arrow/engine/pch.h b/cpp/src/arrow/engine/pch.h
new file mode 100644
index 000000000000..ddb4c120f2a8
--- /dev/null
+++ b/cpp/src/arrow/engine/pch.h
@@ -0,0 +1,23 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// Often-used headers, for precompiling.
+// If updating this header, please make sure you check compilation speed
+// before checking in.  Adding headers which are not used extremely often
+// may incur a slowdown, since it makes the precompiled header heavier to load.
+
+#include "arrow/pch.h"
diff --git a/cpp/src/arrow/engine/simple_extension_type_internal.h b/cpp/src/arrow/engine/simple_extension_type_internal.h
new file mode 100644
index 000000000000..ecffba3d1090
--- /dev/null
+++ b/cpp/src/arrow/engine/simple_extension_type_internal.h
@@ -0,0 +1,183 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "arrow/extension_type.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/optional.h"
+#include "arrow/util/reflection_internal.h"
+#include "arrow/util/string.h"
+
+namespace arrow {
+namespace engine {
+
+template <const util::string_view& kExtensionName, typename Params,
+          typename ParamsProperties, const ParamsProperties* kProperties,
+          std::shared_ptr<DataType> GetStorage(const Params&)>
+class SimpleExtensionType : public ExtensionType {
+ public:
+  using ParamsType = Params;
+
+  explicit SimpleExtensionType(std::shared_ptr<DataType> storage_type, Params params = {})
+      : ExtensionType(std::move(storage_type)), params_(std::move(params)) {}
+
+  static std::shared_ptr<DataType> Make(Params params) {
+    auto storage_type = GetStorage(params);
+    return std::make_shared<SimpleExtensionType>(std::move(storage_type),
+                                                 std::move(params));
+  }
+
+  static const Params* GetIf(const DataType& type) {
+    if (type.id() != Type::EXTENSION) return nullptr;
+
+    const auto& ext_type = ::arrow::internal::checked_cast<const ExtensionType&>(type);
+    if (ext_type.extension_name() != kExtensionName) return nullptr;
+
+    return &::arrow::internal::checked_cast<const SimpleExtensionType&>(type).params_;
+  }
+
+  std::string extension_name() const override { return kExtensionName.to_string(); }
+
+  std::string ToString() const override { return "extension<" + this->Serialize() + ">"; }
+
+  struct ExtensionEqualsImpl {
+    ExtensionEqualsImpl(const Params& l, const Params& r) : left_(l), right_(r) {
+      kProperties->ForEach(*this);
+    }
+
+    template <typename Property>
+    void operator()(const Property& prop, size_t i) {
+      equal_ &= prop.get(left_) == prop.get(right_);
+    }
+
+    const Params& left_;
+    const Params& right_;
+    bool equal_ = true;
+  };
+  bool ExtensionEquals(const ExtensionType& other) const override {
+    if (kExtensionName != other.extension_name()) return false;
+    const auto& other_params = static_cast<const SimpleExtensionType&>(other).params_;
+    return ExtensionEqualsImpl(params_, other_params).equal_;
+  }
+
+  std::shared_ptr<Array> MakeArray(std::shared_ptr<ArrayData> data) const override {
+    DCHECK_EQ(data->type->id(), Type::EXTENSION);
+    DCHECK_EQ(static_cast<const ExtensionType&>(*data->type).extension_name(),
+              kExtensionName);
+    return std::make_shared<ExtensionArray>(data);
+  }
+
+  struct DeserializeImpl {
+    explicit DeserializeImpl(util::string_view repr) {
+      Init(kExtensionName, repr, kProperties->size());
+      kProperties->ForEach(*this);
+    }
+
+    void Fail() { params_ = util::nullopt; }
+
+    void Init(util::string_view class_name, util::string_view repr,
+              size_t num_properties) {
+      if (!repr.starts_with(class_name)) return Fail();
+
+      repr = repr.substr(class_name.size());
+      if (repr.empty()) return Fail();
+      if (repr.front() != '{') return Fail();
+      if (repr.back() != '}') return Fail();
+
+      repr = repr.substr(1, repr.size() - 2);
+      members_ = ::arrow::internal::SplitString(repr, ',');
+      if (members_.size() != num_properties) return Fail();
+    }
+
+    template <typename Property>
+    void operator()(const Property& prop, size_t i) {
+      if (!params_) return;
+
+      auto first_colon = members_[i].find_first_of(':');
+      if (first_colon == util::string_view::npos) return Fail();
+
+      auto name = members_[i].substr(0, first_colon);
+      if (name != prop.name()) return Fail();
+
+      auto value_repr = members_[i].substr(first_colon + 1);
+      typename Property::Type value;
+      try {
+        std::stringstream ss(value_repr.to_string());
+        ss >> value;
+        if (!ss.eof()) return Fail();
+      } catch (...) {
+        return Fail();
+      }
+      prop.set(&*params_, std::move(value));
+    }
+
+    util::optional<Params> params_;
+    std::vector<util::string_view> members_;
+  };
+  Result<std::shared_ptr<DataType>> Deserialize(
+      std::shared_ptr<DataType> storage_type,
+      const std::string& serialized) const override {
+    if (auto params = DeserializeImpl(serialized).params_) {
+      if (!storage_type->Equals(GetStorage(*params))) {
+        return Status::Invalid("Invalid storage type for ", kExtensionName, ": ",
+                               storage_type->ToString(), " (expected ",
+                               GetStorage(*params)->ToString(), ")");
+      }
+
+      return std::make_shared<SimpleExtensionType>(std::move(storage_type),
+                                                   std::move(*params));
+    }
+
+    return Status::Invalid("Could not parse parameters for extension type ",
+                           extension_name(), " from ", serialized);
+  }
+
+  struct SerializeImpl {
+    explicit SerializeImpl(const Params& params)
+        : params_(params), members_(kProperties->size()) {
+      kProperties->ForEach(*this);
+    }
+
+    template <typename Property>
+    void operator()(const Property& prop, size_t i) {
+      std::stringstream ss;
+      ss << prop.name() << ":" << prop.get(params_);
+      members_[i] = ss.str();
+    }
+
+    std::string Finish() {
+      return kExtensionName.to_string() + "{" +
+             ::arrow::internal::JoinStrings(members_, ",") + "}";
+    }
+
+    const Params& params_;
+    std::vector<std::string> members_;
+  };
+  std::string Serialize() const override { return SerializeImpl(params_).Finish(); }
+
+ private:
+  Params params_;
+};
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc
new file mode 100644
index 000000000000..796f9ab5a72c
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/expression_internal.cc
@@ -0,0 +1,902 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// This API is EXPERIMENTAL.
+
+#include "arrow/engine/substrait/expression_internal.h"
+
+#include <utility>
+
+#include "arrow/builder.h"
+#include "arrow/compute/cast.h"
+#include "arrow/compute/exec/expression.h"
+#include "arrow/compute/exec/expression_internal.h"
+#include "arrow/engine/substrait/extension_types.h"
+#include "arrow/engine/substrait/type_internal.h"
+#include "arrow/engine/visibility.h"
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/util/make_unique.h"
+#include "arrow/visit_scalar_inline.h"
+
+namespace arrow {
+
+using internal::checked_cast;
+
+namespace engine {
+
+namespace internal {
+using ::arrow::internal::make_unique;
+}  // namespace internal
+
+namespace {
+
+std::shared_ptr<FixedSizeBinaryScalar> FixedSizeBinaryScalarFromBytes(
+    const std::string& bytes) {
+  auto buf = Buffer::FromString(bytes);
+  auto type = fixed_size_binary(static_cast<int>(buf->size()));
+  return std::make_shared<FixedSizeBinaryScalar>(std::move(buf), std::move(type));
+}
+
+}  // namespace
+
+Result<compute::Expression> FromProto(const substrait::Expression& expr,
+                                      const ExtensionSet& ext_set) {
+  switch (expr.rex_type_case()) {
+    case substrait::Expression::kLiteral: {
+      ARROW_ASSIGN_OR_RAISE(auto datum, FromProto(expr.literal(), ext_set));
+      return compute::literal(std::move(datum));
+    }
+
+    case substrait::Expression::kSelection: {
+      if (!expr.selection().has_direct_reference()) break;
+
+      util::optional<compute::Expression> out;
+      if (expr.selection().has_expression()) {
+        ARROW_ASSIGN_OR_RAISE(out, FromProto(expr.selection().expression(), ext_set));
+      }
+
+      const auto* ref = &expr.selection().direct_reference();
+      while (ref != nullptr) {
+        switch (ref->reference_type_case()) {
+          case substrait::Expression::ReferenceSegment::kStructField: {
+            auto index = ref->struct_field().field();
+            if (!out) {
+              // Root StructField (column selection)
+              out = compute::field_ref(FieldRef(index));
+            } else if (auto out_ref = out->field_ref()) {
+              // Nested StructFields on the root (selection of struct-typed column
+              // combined with selecting struct fields)
+              out = compute::field_ref(FieldRef(*out_ref, index));
+            } else if (out->call() && out->call()->function_name == "struct_field") {
+              // Nested StructFields on top of an arbitrary expression
+              std::static_pointer_cast<arrow::compute::StructFieldOptions>(
+                  out->call()->options)
+                  ->indices.push_back(index);
+            } else {
+              // First StructField on top of an arbitrary expression
+              out = compute::call("struct_field", {std::move(*out)},
+                                  arrow::compute::StructFieldOptions({index}));
+            }
+
+            // Segment handled, continue with child segment (if any)
+            if (ref->struct_field().has_child()) {
+              ref = &ref->struct_field().child();
+            } else {
+              ref = nullptr;
+            }
+            break;
+          }
+          case substrait::Expression::ReferenceSegment::kListElement: {
+            if (!out) {
+              // Root ListField (illegal)
+              return Status::Invalid(
+                  "substrait::ListElement cannot take a Relation as an argument");
+            }
+
+            // ListField on top of an arbitrary expression
+            out = compute::call(
+                "list_element",
+                {std::move(*out), compute::literal(ref->list_element().offset())});
+
+            // Segment handled, continue with child segment (if any)
+            if (ref->list_element().has_child()) {
+              ref = &ref->list_element().child();
+            } else {
+              ref = nullptr;
+            }
+            break;
+          }
+          default:
+            // Unimplemented construct, break out of loop
+            out.reset();
+            ref = nullptr;
+        }
+      }
+      if (out) {
+        return *std::move(out);
+      }
+      break;
+    }
+
+    case substrait::Expression::kIfThen: {
+      const auto& if_then = expr.if_then();
+      if (!if_then.has_else_()) break;
+      if (if_then.ifs_size() == 0) break;
+
+      if (if_then.ifs_size() == 1) {
+        ARROW_ASSIGN_OR_RAISE(auto if_, FromProto(if_then.ifs(0).if_(), ext_set));
+        ARROW_ASSIGN_OR_RAISE(auto then, FromProto(if_then.ifs(0).then(), ext_set));
+        ARROW_ASSIGN_OR_RAISE(auto else_, FromProto(if_then.else_(), ext_set));
+        return compute::call("if_else",
+                             {std::move(if_), std::move(then), std::move(else_)});
+      }
+
+      std::vector<compute::Expression> conditions, args;
+      std::vector<std::string> condition_names;
+      conditions.reserve(if_then.ifs_size());
+      condition_names.reserve(if_then.ifs_size());
+      size_t name_counter = 0;
+      args.reserve(if_then.ifs_size() + 2);
+      args.emplace_back();
+      for (auto if_ : if_then.ifs()) {
+        ARROW_ASSIGN_OR_RAISE(auto compute_if, FromProto(if_.if_(), ext_set));
+        ARROW_ASSIGN_OR_RAISE(auto compute_then, FromProto(if_.then(), ext_set));
+        conditions.emplace_back(std::move(compute_if));
+        args.emplace_back(std::move(compute_then));
+        condition_names.emplace_back("cond" + std::to_string(++name_counter));
+      }
+      ARROW_ASSIGN_OR_RAISE(auto compute_else, FromProto(if_then.else_(), ext_set));
+      args.emplace_back(std::move(compute_else));
+      args[0] = compute::call("make_struct", std::move(conditions),
+                              compute::MakeStructOptions(condition_names));
+      return compute::call("case_when", std::move(args));
+    }
+
+    case substrait::Expression::kScalarFunction: {
+      const auto& scalar_fn = expr.scalar_function();
+
+      auto id = ext_set.function_ids()[scalar_fn.function_reference()];
+
+      std::vector<compute::Expression> arguments(scalar_fn.args_size());
+      for (int i = 0; i < scalar_fn.args_size(); ++i) {
+        ARROW_ASSIGN_OR_RAISE(arguments[i], FromProto(scalar_fn.args(i), ext_set));
+      }
+
+      return compute::call(id.name.to_string(), std::move(arguments));
+    }
+
+    default:
+      break;
+  }
+
+  return Status::NotImplemented("conversion to arrow::compute::Expression from ",
+                                expr.DebugString());
+}
+
+Result<Datum> FromProto(const substrait::Expression::Literal& lit,
+                        const ExtensionSet& ext_set) {
+  if (lit.nullable()) {
+    // FIXME not sure how this field should be interpreted and there's no way to round
+    // trip it through arrow
+    return Status::Invalid(
+        "Nullable Literals - Literal.nullable must be left at the default");
+  }
+
+  switch (lit.literal_type_case()) {
+    case substrait::Expression::Literal::kBoolean:
+      return Datum(lit.boolean());
+
+    case substrait::Expression::Literal::kI8:
+      return Datum(static_cast<int8_t>(lit.i8()));
+    case substrait::Expression::Literal::kI16:
+      return Datum(static_cast<int16_t>(lit.i16()));
+    case substrait::Expression::Literal::kI32:
+      return Datum(static_cast<int32_t>(lit.i32()));
+    case substrait::Expression::Literal::kI64:
+      return Datum(static_cast<int64_t>(lit.i64()));
+
+    case substrait::Expression::Literal::kFp32:
+      return Datum(lit.fp32());
+    case substrait::Expression::Literal::kFp64:
+      return Datum(lit.fp64());
+
+    case substrait::Expression::Literal::kString:
+      return Datum(lit.string());
+    case substrait::Expression::Literal::kBinary:
+      return Datum(BinaryScalar(Buffer::FromString(lit.binary())));
+
+    case substrait::Expression::Literal::kTimestamp:
+      return Datum(
+          TimestampScalar(static_cast<int64_t>(lit.timestamp()), TimeUnit::MICRO));
+
+    case substrait::Expression::Literal::kTimestampTz:
+      return Datum(TimestampScalar(static_cast<int64_t>(lit.timestamp_tz()),
+                                   TimeUnit::MICRO, TimestampTzTimezoneString()));
+
+    case substrait::Expression::Literal::kDate:
+      return Datum(Date64Scalar(static_cast<int64_t>(lit.date())));
+    case substrait::Expression::Literal::kTime:
+      return Datum(Time64Scalar(static_cast<int64_t>(lit.time()), TimeUnit::MICRO));
+
+    case substrait::Expression::Literal::kIntervalYearToMonth:
+    case substrait::Expression::Literal::kIntervalDayToSecond: {
+      Int32Builder builder;
+      std::shared_ptr<DataType> type;
+      if (lit.has_interval_year_to_month()) {
+        RETURN_NOT_OK(builder.Append(lit.interval_year_to_month().years()));
+        RETURN_NOT_OK(builder.Append(lit.interval_year_to_month().months()));
+        type = interval_year();
+      } else {
+        RETURN_NOT_OK(builder.Append(lit.interval_day_to_second().days()));
+        RETURN_NOT_OK(builder.Append(lit.interval_day_to_second().seconds()));
+        type = interval_day();
+      }
+      ARROW_ASSIGN_OR_RAISE(auto array, builder.Finish());
+      return Datum(
+          ExtensionScalar(FixedSizeListScalar(std::move(array)), std::move(type)));
+    }
+
+    case substrait::Expression::Literal::kUuid:
+      return Datum(ExtensionScalar(FixedSizeBinaryScalarFromBytes(lit.uuid()), uuid()));
+
+    case substrait::Expression::Literal::kFixedChar:
+      return Datum(
+          ExtensionScalar(FixedSizeBinaryScalarFromBytes(lit.fixed_char()),
+                          fixed_char(static_cast<int32_t>(lit.fixed_char().size()))));
+
+    case substrait::Expression::Literal::kVarChar:
+      return Datum(
+          ExtensionScalar(StringScalar(lit.var_char().value()),
+                          varchar(static_cast<int32_t>(lit.var_char().length()))));
+
+    case substrait::Expression::Literal::kFixedBinary:
+      return Datum(FixedSizeBinaryScalarFromBytes(lit.fixed_binary()));
+
+    case substrait::Expression::Literal::kDecimal: {
+      if (lit.decimal().value().size() != sizeof(Decimal128)) {
+        return Status::Invalid("Decimal literal had ", lit.decimal().value().size(),
+                               " bytes (expected ", sizeof(Decimal128), ")");
+      }
+
+      Decimal128 value;
+      std::memcpy(value.mutable_native_endian_bytes(), lit.decimal().value().data(),
+                  sizeof(Decimal128));
+#if !ARROW_LITTLE_ENDIAN
+      std::reverse(value.mutable_native_endian_bytes(),
+                   value.mutable_native_endian_bytes() + sizeof(Decimal128));
+#endif
+      auto type = decimal128(lit.decimal().precision(), lit.decimal().scale());
+      return Datum(Decimal128Scalar(value, std::move(type)));
+    }
+
+    case substrait::Expression::Literal::kStruct: {
+      const auto& struct_ = lit.struct_();
+
+      ScalarVector fields(struct_.fields_size());
+      std::vector<std::string> field_names(fields.size(), "");
+      for (int i = 0; i < struct_.fields_size(); ++i) {
+        ARROW_ASSIGN_OR_RAISE(auto field, FromProto(struct_.fields(i), ext_set));
+        DCHECK(field.is_scalar());
+        fields[i] = field.scalar();
+      }
+      ARROW_ASSIGN_OR_RAISE(
+          auto scalar, StructScalar::Make(std::move(fields), std::move(field_names)));
+      return Datum(std::move(scalar));
+    }
+
+    case substrait::Expression::Literal::kList: {
+      const auto& list = lit.list();
+      if (list.values_size() == 0) {
+        return Status::Invalid(
+            "substrait::Expression::Literal::List had no values; should have been an "
+            "substrait::Expression::Literal::EmptyList");
+      }
+
+      std::shared_ptr<DataType> element_type;
+
+      ScalarVector values(list.values_size());
+      for (int i = 0; i < list.values_size(); ++i) {
+        ARROW_ASSIGN_OR_RAISE(auto value, FromProto(list.values(i), ext_set));
+        DCHECK(value.is_scalar());
+        values[i] = value.scalar();
+        if (element_type) {
+          if (!value.type()->Equals(*element_type)) {
+            return Status::Invalid(
+                list.DebugString(),
+                " has a value whose type doesn't match the other list values");
+          }
+        } else {
+          element_type = value.type();
+        }
+      }
+
+      ARROW_ASSIGN_OR_RAISE(auto builder, MakeBuilder(std::move(element_type)));
+      RETURN_NOT_OK(builder->AppendScalars(values));
+      ARROW_ASSIGN_OR_RAISE(auto arr, builder->Finish());
+      return Datum(ListScalar(std::move(arr)));
+    }
+
+    case substrait::Expression::Literal::kMap: {
+      const auto& map = lit.map();
+      if (map.key_values_size() == 0) {
+        return Status::Invalid(
+            "substrait::Expression::Literal::Map had no values; should have been an "
+            "substrait::Expression::Literal::EmptyMap");
+      }
+
+      std::shared_ptr<DataType> key_type, value_type;
+      ScalarVector keys(map.key_values_size()), values(map.key_values_size());
+      for (int i = 0; i < map.key_values_size(); ++i) {
+        const auto& kv = map.key_values(i);
+
+        static const std::array<char const*, 4> kMissing = {"key and value", "value",
+                                                            "key", nullptr};
+        if (auto missing = kMissing[kv.has_key() + kv.has_value() * 2]) {
+          return Status::Invalid("While converting to MapScalar encountered missing ",
+                                 missing, " in ", map.DebugString());
+        }
+        ARROW_ASSIGN_OR_RAISE(auto key, FromProto(kv.key(), ext_set));
+        ARROW_ASSIGN_OR_RAISE(auto value, FromProto(kv.value(), ext_set));
+
+        DCHECK(key.is_scalar());
+        DCHECK(value.is_scalar());
+
+        keys[i] = key.scalar();
+        values[i] = value.scalar();
+
+        if (key_type) {
+          if (!key.type()->Equals(*key_type)) {
+            return Status::Invalid(map.DebugString(),
+                                   " has a key whose type doesn't match key_type");
+          }
+        } else {
+          key_type = value.type();
+        }
+
+        if (value_type) {
+          if (!value.type()->Equals(*value_type)) {
+            return Status::Invalid(map.DebugString(),
+                                   " has a value whose type doesn't match value_type");
+          }
+        } else {
+          value_type = value.type();
+        }
+      }
+
+      ARROW_ASSIGN_OR_RAISE(auto key_builder, MakeBuilder(key_type));
+      ARROW_ASSIGN_OR_RAISE(auto value_builder, MakeBuilder(value_type));
+      RETURN_NOT_OK(key_builder->AppendScalars(keys));
+      RETURN_NOT_OK(value_builder->AppendScalars(values));
+      ARROW_ASSIGN_OR_RAISE(auto key_arr, key_builder->Finish());
+      ARROW_ASSIGN_OR_RAISE(auto value_arr, value_builder->Finish());
+      ARROW_ASSIGN_OR_RAISE(
+          auto kv_arr,
+          StructArray::Make(ArrayVector{std::move(key_arr), std::move(value_arr)},
+                            std::vector<std::string>{"key", "value"}));
+      return Datum(std::make_shared<MapScalar>(std::move(kv_arr)));
+    }
+
+    case substrait::Expression::Literal::kEmptyList: {
+      ARROW_ASSIGN_OR_RAISE(auto type_nullable,
+                            FromProto(lit.empty_list().type(), ext_set));
+      ARROW_ASSIGN_OR_RAISE(auto values, MakeEmptyArray(type_nullable.first));
+      return ListScalar{std::move(values)};
+    }
+
+    case substrait::Expression::Literal::kEmptyMap: {
+      ARROW_ASSIGN_OR_RAISE(auto key_type_nullable,
+                            FromProto(lit.empty_map().key(), ext_set));
+      ARROW_ASSIGN_OR_RAISE(auto keys,
+                            MakeEmptyArray(std::move(key_type_nullable.first)));
+
+      ARROW_ASSIGN_OR_RAISE(auto value_type_nullable,
+                            FromProto(lit.empty_map().value(), ext_set));
+      ARROW_ASSIGN_OR_RAISE(auto values,
+                            MakeEmptyArray(std::move(value_type_nullable.first)));
+
+      auto map_type = std::make_shared<MapType>(keys->type(), values->type());
+      ARROW_ASSIGN_OR_RAISE(
+          auto key_values,
+          StructArray::Make(
+              {std::move(keys), std::move(values)},
+              checked_cast<const ListType&>(*map_type).value_type()->fields()));
+
+      return MapScalar{std::move(key_values)};
+    }
+
+    case substrait::Expression::Literal::kNull: {
+      ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(lit.null(), ext_set));
+      if (!type_nullable.second) {
+        return Status::Invalid("Null literal ", lit.DebugString(),
+                               " is of non-nullable type");
+      }
+
+      return Datum(MakeNullScalar(std::move(type_nullable.first)));
+    }
+
+    default:
+      break;
+  }
+
+  return Status::NotImplemented("conversion to arrow::Datum from ", lit.DebugString());
+}
+
+namespace {
+struct ScalarToProtoImpl {
+  Status Visit(const NullScalar& s) { return NotImplemented(s); }
+
+  using Lit = substrait::Expression::Literal;
+
+  template <typename Arg, typename PrimitiveScalar>
+  Status Primitive(void (substrait::Expression::Literal::*set)(Arg),
+                   const PrimitiveScalar& primitive_scalar) {
+    (lit_->*set)(static_cast<Arg>(primitive_scalar.value));
+    return Status::OK();
+  }
+
+  template <typename ScalarWithBufferValue>
+  Status FromBuffer(void (substrait::Expression::Literal::*set)(std::string&&),
+                    const ScalarWithBufferValue& scalar_with_buffer) {
+    (lit_->*set)(scalar_with_buffer.value->ToString());
+    return Status::OK();
+  }
+
+  Status Visit(const BooleanScalar& s) { return Primitive(&Lit::set_boolean, s); }
+
+  Status Visit(const Int8Scalar& s) { return Primitive(&Lit::set_i8, s); }
+  Status Visit(const Int16Scalar& s) { return Primitive(&Lit::set_i16, s); }
+  Status Visit(const Int32Scalar& s) { return Primitive(&Lit::set_i32, s); }
+  Status Visit(const Int64Scalar& s) { return Primitive(&Lit::set_i64, s); }
+
+  Status Visit(const UInt8Scalar& s) { return NotImplemented(s); }
+  Status Visit(const UInt16Scalar& s) { return NotImplemented(s); }
+  Status Visit(const UInt32Scalar& s) { return NotImplemented(s); }
+  Status Visit(const UInt64Scalar& s) { return NotImplemented(s); }
+
+  Status Visit(const HalfFloatScalar& s) { return NotImplemented(s); }
+  Status Visit(const FloatScalar& s) { return Primitive(&Lit::set_fp32, s); }
+  Status Visit(const DoubleScalar& s) { return Primitive(&Lit::set_fp64, s); }
+
+  Status Visit(const StringScalar& s) { return FromBuffer(&Lit::set_string, s); }
+  Status Visit(const BinaryScalar& s) { return FromBuffer(&Lit::set_binary, s); }
+
+  Status Visit(const FixedSizeBinaryScalar& s) {
+    return FromBuffer(&Lit::set_fixed_binary, s);
+  }
+
+  Status Visit(const Date32Scalar& s) { return NotImplemented(s); }
+  Status Visit(const Date64Scalar& s) { return Primitive(&Lit::set_date, s); }
+
+  Status Visit(const TimestampScalar& s) {
+    const auto& t = checked_cast<const TimestampType&>(*s.type);
+
+    if (t.unit() != TimeUnit::MICRO) return NotImplemented(s);
+
+    if (t.timezone() == "") return Primitive(&Lit::set_timestamp, s);
+
+    if (t.timezone() == TimestampTzTimezoneString()) {
+      return Primitive(&Lit::set_timestamp_tz, s);
+    }
+
+    return NotImplemented(s);
+  }
+
+  Status Visit(const Time32Scalar& s) { return NotImplemented(s); }
+  Status Visit(const Time64Scalar& s) {
+    if (checked_cast<const Time64Type&>(*s.type).unit() != TimeUnit::MICRO) {
+      return NotImplemented(s);
+    }
+    return Primitive(&Lit::set_time, s);
+  }
+
+  Status Visit(const MonthIntervalScalar& s) { return NotImplemented(s); }
+  Status Visit(const DayTimeIntervalScalar& s) { return NotImplemented(s); }
+
+  Status Visit(const Decimal128Scalar& s) {
+    auto decimal = internal::make_unique<Lit::Decimal>();
+
+    auto decimal_type = checked_cast<const Decimal128Type*>(s.type.get());
+    decimal->set_precision(decimal_type->precision());
+    decimal->set_scale(decimal_type->scale());
+
+    decimal->set_value(reinterpret_cast<const char*>(s.value.native_endian_bytes()),
+                       sizeof(Decimal128));
+#if !ARROW_LITTLE_ENDIAN
+    std::reverse(decimal->mutable_value()->begin(), decimal->mutable_value()->end());
+#endif
+    lit_->set_allocated_decimal(decimal.release());
+    return Status::OK();
+  }
+
+  Status Visit(const Decimal256Scalar& s) { return NotImplemented(s); }
+
+  Status Visit(const ListScalar& s) {
+    if (s.value->length() == 0) {
+      ARROW_ASSIGN_OR_RAISE(auto list_type,
+                            ToProto(*s.type, /*nullable=*/true, ext_set_));
+      lit_->set_allocated_empty_list(list_type->release_list());
+      return Status::OK();
+    }
+
+    lit_->set_allocated_list(new Lit::List());
+
+    const auto& list_type = checked_cast<const ListType&>(*s.type);
+    ARROW_ASSIGN_OR_RAISE(
+        auto element_type,
+        ToProto(*list_type.value_type(), list_type.value_field()->nullable(), ext_set_));
+
+    auto values = lit_->mutable_list()->mutable_values();
+    values->Reserve(static_cast<int>(s.value->length()));
+
+    for (int64_t i = 0; i < s.value->length(); ++i) {
+      ARROW_ASSIGN_OR_RAISE(Datum list_element, s.value->GetScalar(i));
+      ARROW_ASSIGN_OR_RAISE(auto lit, ToProto(list_element, ext_set_));
+      values->AddAllocated(lit.release());
+    }
+    return Status::OK();
+  }
+
+  Status Visit(const StructScalar& s) {
+    lit_->set_allocated_struct_(new Lit::Struct());
+
+    auto fields = lit_->mutable_struct_()->mutable_fields();
+    fields->Reserve(static_cast<int>(s.value.size()));
+
+    for (Datum field : s.value) {
+      ARROW_ASSIGN_OR_RAISE(auto lit, ToProto(field, ext_set_));
+      fields->AddAllocated(lit.release());
+    }
+    return Status::OK();
+  }
+
+  Status Visit(const SparseUnionScalar& s) { return NotImplemented(s); }
+  Status Visit(const DenseUnionScalar& s) { return NotImplemented(s); }
+  Status Visit(const DictionaryScalar& s) { return NotImplemented(s); }
+
+  Status Visit(const MapScalar& s) {
+    if (s.value->length() == 0) {
+      ARROW_ASSIGN_OR_RAISE(auto map_type, ToProto(*s.type, /*nullable=*/true, ext_set_));
+      lit_->set_allocated_empty_map(map_type->release_map());
+      return Status::OK();
+    }
+
+    lit_->set_allocated_map(new Lit::Map());
+
+    const auto& kv_arr = checked_cast<const StructArray&>(*s.value);
+
+    auto key_values = lit_->mutable_map()->mutable_key_values();
+    key_values->Reserve(static_cast<int>(kv_arr.length()));
+
+    for (int64_t i = 0; i < s.value->length(); ++i) {
+      auto kv = internal::make_unique<Lit::Map::KeyValue>();
+
+      ARROW_ASSIGN_OR_RAISE(Datum key_scalar, kv_arr.field(0)->GetScalar(i));
+      ARROW_ASSIGN_OR_RAISE(auto key, ToProto(key_scalar, ext_set_));
+      kv->set_allocated_key(key.release());
+
+      ARROW_ASSIGN_OR_RAISE(Datum value_scalar, kv_arr.field(1)->GetScalar(i));
+      ARROW_ASSIGN_OR_RAISE(auto value, ToProto(value_scalar, ext_set_));
+      kv->set_allocated_value(value.release());
+
+      key_values->AddAllocated(kv.release());
+    }
+    return Status::OK();
+  }
+
+  Status Visit(const ExtensionScalar& s) {
+    if (UnwrapUuid(*s.type)) {
+      return FromBuffer(&Lit::set_uuid,
+                        checked_cast<const FixedSizeBinaryScalar&>(*s.value));
+    }
+
+    if (UnwrapFixedChar(*s.type)) {
+      return FromBuffer(&Lit::set_fixed_char,
+                        checked_cast<const FixedSizeBinaryScalar&>(*s.value));
+    }
+
+    if (auto length = UnwrapVarChar(*s.type)) {
+      auto var_char = internal::make_unique<Lit::VarChar>();
+      var_char->set_length(*length);
+      var_char->set_value(checked_cast<const StringScalar&>(*s.value).value->ToString());
+
+      lit_->set_allocated_var_char(var_char.release());
+      return Status::OK();
+    }
+
+    auto GetPairOfInts = [&] {
+      const auto& array = *checked_cast<const FixedSizeListScalar&>(*s.value).value;
+      auto ints = checked_cast<const Int32Array&>(array).raw_values();
+      return std::make_pair(ints[0], ints[1]);
+    };
+
+    if (UnwrapIntervalYear(*s.type)) {
+      auto interval_year = internal::make_unique<Lit::IntervalYearToMonth>();
+      interval_year->set_years(GetPairOfInts().first);
+      interval_year->set_months(GetPairOfInts().second);
+
+      lit_->set_allocated_interval_year_to_month(interval_year.release());
+      return Status::OK();
+    }
+
+    if (UnwrapIntervalDay(*s.type)) {
+      auto interval_day = internal::make_unique<Lit::IntervalDayToSecond>();
+      interval_day->set_days(GetPairOfInts().first);
+      interval_day->set_seconds(GetPairOfInts().second);
+
+      lit_->set_allocated_interval_day_to_second(interval_day.release());
+      return Status::OK();
+    }
+
+    return NotImplemented(s);
+  }
+
+  Status Visit(const FixedSizeListScalar& s) { return NotImplemented(s); }
+  Status Visit(const DurationScalar& s) { return NotImplemented(s); }
+  Status Visit(const LargeStringScalar& s) { return NotImplemented(s); }
+  Status Visit(const LargeBinaryScalar& s) { return NotImplemented(s); }
+  Status Visit(const LargeListScalar& s) { return NotImplemented(s); }
+  Status Visit(const MonthDayNanoIntervalScalar& s) { return NotImplemented(s); }
+
+  Status NotImplemented(const Scalar& s) {
+    return Status::NotImplemented("conversion to substrait::Expression::Literal from ",
+                                  s.ToString());
+  }
+
+  Status operator()(const Scalar& scalar) { return VisitScalarInline(scalar, this); }
+
+  substrait::Expression::Literal* lit_;
+  ExtensionSet* ext_set_;
+};
+}  // namespace
+
+Result<std::unique_ptr<substrait::Expression::Literal>> ToProto(const Datum& datum,
+                                                                ExtensionSet* ext_set) {
+  if (!datum.is_scalar()) {
+    return Status::NotImplemented("representing ", datum.ToString(),
+                                  " as a substrait::Expression::Literal");
+  }
+
+  auto out = internal::make_unique<substrait::Expression::Literal>();
+
+  if (datum.scalar()->is_valid) {
+    RETURN_NOT_OK((ScalarToProtoImpl{out.get(), ext_set})(*datum.scalar()));
+  } else {
+    ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*datum.type(), /*nullable=*/true, ext_set));
+    out->set_allocated_null(type.release());
+  }
+
+  return std::move(out);
+}
+
+static Status AddChildToReferenceSegment(
+    substrait::Expression::ReferenceSegment& segment,
+    std::unique_ptr<substrait::Expression::ReferenceSegment>&& child) {
+  auto status = Status::Invalid("Attempt to add child to incomplete reference segment");
+  switch (segment.reference_type_case()) {
+    case substrait::Expression::ReferenceSegment::kMapKey: {
+      auto map_key = segment.mutable_map_key();
+      if (map_key->has_child()) {
+        status = AddChildToReferenceSegment(*map_key->mutable_child(), std::move(child));
+      } else {
+        map_key->set_allocated_child(child.release());
+        status = Status::OK();
+      }
+      break;
+    }
+    case substrait::Expression::ReferenceSegment::kStructField: {
+      auto struct_field = segment.mutable_struct_field();
+      if (struct_field->has_child()) {
+        status =
+            AddChildToReferenceSegment(*struct_field->mutable_child(), std::move(child));
+      } else {
+        struct_field->set_allocated_child(child.release());
+        status = Status::OK();
+      }
+      break;
+    }
+    case substrait::Expression::ReferenceSegment::kListElement: {
+      auto list_element = segment.mutable_list_element();
+      if (list_element->has_child()) {
+        status =
+            AddChildToReferenceSegment(*list_element->mutable_child(), std::move(child));
+      } else {
+        list_element->set_allocated_child(child.release());
+        status = Status::OK();
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return status;
+}
+
+// Indexes the given Substrait expression or root (if expr is empty) using the given
+// ReferenceSegment.
+static Result<std::unique_ptr<substrait::Expression>> MakeDirectReference(
+    std::unique_ptr<substrait::Expression>&& expr,
+    std::unique_ptr<substrait::Expression::ReferenceSegment>&& ref_segment) {
+  // If expr is already a selection expression, add the index to its index stack.
+  if (expr && expr->has_selection() && expr->selection().has_direct_reference()) {
+    auto selection = expr->mutable_selection();
+    auto root_ref_segment = selection->mutable_direct_reference();
+    auto status = AddChildToReferenceSegment(*root_ref_segment, std::move(ref_segment));
+    if (status.ok()) {
+      return std::move(expr);
+    }
+  }
+
+  auto selection = internal::make_unique<substrait::Expression::FieldReference>();
+  selection->set_allocated_direct_reference(ref_segment.release());
+
+  if (expr && expr->rex_type_case() != substrait::Expression::REX_TYPE_NOT_SET) {
+    selection->set_allocated_expression(expr.release());
+  } else {
+    selection->set_allocated_root_reference(
+        new substrait::Expression::FieldReference::RootReference());
+  }
+
+  auto out = internal::make_unique<substrait::Expression>();
+  out->set_allocated_selection(selection.release());
+  return std::move(out);
+}
+
+// Indexes the given Substrait struct-typed expression or root (if expr is empty) using
+// the given field index.
+static Result<std::unique_ptr<substrait::Expression>> MakeStructFieldReference(
+    std::unique_ptr<substrait::Expression>&& expr, int field) {
+  auto struct_field =
+      internal::make_unique<substrait::Expression::ReferenceSegment::StructField>();
+  struct_field->set_field(field);
+
+  auto ref_segment = internal::make_unique<substrait::Expression::ReferenceSegment>();
+  ref_segment->set_allocated_struct_field(struct_field.release());
+
+  return MakeDirectReference(std::move(expr), std::move(ref_segment));
+}
+
+// Indexes the given Substrait list-typed expression using the given offset.
+static Result<std::unique_ptr<substrait::Expression>> MakeListElementReference(
+    std::unique_ptr<substrait::Expression>&& expr, int offset) {
+  auto list_element =
+      internal::make_unique<substrait::Expression::ReferenceSegment::ListElement>();
+  list_element->set_offset(offset);
+
+  auto ref_segment = internal::make_unique<substrait::Expression::ReferenceSegment>();
+  ref_segment->set_allocated_list_element(list_element.release());
+
+  return MakeDirectReference(std::move(expr), std::move(ref_segment));
+}
+
+Result<std::unique_ptr<substrait::Expression>> ToProto(const compute::Expression& expr,
+                                                       ExtensionSet* ext_set) {
+  if (!expr.IsBound()) {
+    return Status::Invalid("ToProto requires a bound Expression");
+  }
+
+  auto out = internal::make_unique<substrait::Expression>();
+
+  if (auto datum = expr.literal()) {
+    ARROW_ASSIGN_OR_RAISE(auto literal, ToProto(*datum, ext_set));
+    out->set_allocated_literal(literal.release());
+    return std::move(out);
+  }
+
+  if (auto param = expr.parameter()) {
+    // Special case of a nested StructField
+    DCHECK(!param->indices.empty());
+
+    for (int index : param->indices) {
+      ARROW_ASSIGN_OR_RAISE(out, MakeStructFieldReference(std::move(out), index));
+    }
+
+    return std::move(out);
+  }
+
+  auto call = CallNotNull(expr);
+
+  if (call->function_name == "case_when") {
+    auto conditions = call->arguments[0].call();
+    if (conditions && conditions->function_name == "make_struct") {
+      // catch the special case of calls convertible to IfThen
+      auto if_then_ = internal::make_unique<substrait::Expression::IfThen>();
+
+      // don't try to convert argument 0 of the case_when; we have to convert the elements
+      // of make_struct individually
+      std::vector<std::unique_ptr<substrait::Expression>> arguments(
+          call->arguments.size() - 1);
+      for (size_t i = 1; i < call->arguments.size(); ++i) {
+        ARROW_ASSIGN_OR_RAISE(arguments[i - 1], ToProto(call->arguments[i], ext_set));
+      }
+
+      for (size_t i = 0; i < conditions->arguments.size(); ++i) {
+        ARROW_ASSIGN_OR_RAISE(auto cond_substrait,
+                              ToProto(conditions->arguments[i], ext_set));
+        auto clause = internal::make_unique<substrait::Expression::IfThen::IfClause>();
+        clause->set_allocated_if_(cond_substrait.release());
+        clause->set_allocated_then(arguments[i].release());
+        if_then_->mutable_ifs()->AddAllocated(clause.release());
+      }
+
+      if_then_->set_allocated_else_(arguments.back().release());
+
+      out->set_allocated_if_then(if_then_.release());
+      return std::move(out);
+    }
+  }
+
+  // the remaining function pattern matchers only convert the function itself, so we
+  // should be able to convert all its arguments first here
+  std::vector<std::unique_ptr<substrait::Expression>> arguments(call->arguments.size());
+  for (size_t i = 0; i < arguments.size(); ++i) {
+    ARROW_ASSIGN_OR_RAISE(arguments[i], ToProto(call->arguments[i], ext_set));
+  }
+
+  if (call->function_name == "struct_field") {
+    // catch the special case of calls convertible to a StructField
+    out = std::move(arguments[0]);
+    for (int index :
+         checked_cast<const arrow::compute::StructFieldOptions&>(*call->options)
+             .indices) {
+      ARROW_ASSIGN_OR_RAISE(out, MakeStructFieldReference(std::move(out), index));
+    }
+
+    return std::move(out);
+  }
+
+  if (call->function_name == "list_element") {
+    // catch the special case of calls convertible to a ListElement
+    if (arguments[0]->has_selection() &&
+        arguments[0]->selection().has_direct_reference()) {
+      if (arguments[1]->has_literal() && arguments[1]->literal().has_i32()) {
+        return MakeListElementReference(std::move(arguments[0]),
+                                        arguments[1]->literal().i32());
+      }
+    }
+  }
+
+  if (call->function_name == "if_else") {
+    // catch the special case of calls convertible to IfThen
+    auto if_clause = internal::make_unique<substrait::Expression::IfThen::IfClause>();
+    if_clause->set_allocated_if_(arguments[0].release());
+    if_clause->set_allocated_then(arguments[1].release());
+
+    auto if_then = internal::make_unique<substrait::Expression::IfThen>();
+    if_then->mutable_ifs()->AddAllocated(if_clause.release());
+    if_then->set_allocated_else_(arguments[2].release());
+
+    out->set_allocated_if_then(if_then.release());
+    return std::move(out);
+  }
+
+  // other expression types dive into extensions immediately
+  ARROW_ASSIGN_OR_RAISE(auto anchor, ext_set->EncodeFunction(call->function_name));
+
+  auto scalar_fn = internal::make_unique<substrait::Expression::ScalarFunction>();
+  scalar_fn->set_function_reference(anchor);
+  scalar_fn->mutable_args()->Reserve(static_cast<int>(arguments.size()));
+  for (auto& arg : arguments) {
+    scalar_fn->mutable_args()->AddAllocated(arg.release());
+  }
+
+  out->set_allocated_scalar_function(scalar_fn.release());
+  return std::move(out);
+}
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/expression_internal.h b/cpp/src/arrow/engine/substrait/expression_internal.h
new file mode 100644
index 000000000000..332b173b6776
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/expression_internal.h
@@ -0,0 +1,49 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// This API is EXPERIMENTAL.
+
+#pragma once
+
+#include <utility>
+
+#include "arrow/compute/type_fwd.h"
+#include "arrow/engine/substrait/extension_set.h"
+#include "arrow/engine/visibility.h"
+#include "arrow/type_fwd.h"
+
+#include "generated/substrait/expression.pb.h"  // IWYU pragma: export
+
+namespace arrow {
+namespace engine {
+
+ARROW_ENGINE_EXPORT
+Result<compute::Expression> FromProto(const substrait::Expression&, const ExtensionSet&);
+
+ARROW_ENGINE_EXPORT
+Result<std::unique_ptr<substrait::Expression>> ToProto(const compute::Expression&,
+                                                       ExtensionSet*);
+
+ARROW_ENGINE_EXPORT
+Result<Datum> FromProto(const substrait::Expression::Literal&, const ExtensionSet&);
+
+ARROW_ENGINE_EXPORT
+Result<std::unique_ptr<substrait::Expression::Literal>> ToProto(const Datum&,
+                                                                ExtensionSet*);
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/extension_set.cc b/cpp/src/arrow/engine/substrait/extension_set.cc
new file mode 100644
index 000000000000..084f8f3bb4f4
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/extension_set.cc
@@ -0,0 +1,346 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/engine/substrait/extension_set.h"
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "arrow/util/hash_util.h"
+#include "arrow/util/hashing.h"
+#include "arrow/util/string_view.h"
+
+namespace arrow {
+namespace engine {
+namespace {
+
+struct TypePtrHashEq {
+  template <typename Ptr>
+  size_t operator()(const Ptr& type) const {
+    return type->Hash();
+  }
+
+  template <typename Ptr>
+  bool operator()(const Ptr& l, const Ptr& r) const {
+    return *l == *r;
+  }
+};
+
+struct IdHashEq {
+  using Id = ExtensionSet::Id;
+
+  size_t operator()(Id id) const {
+    constexpr ::arrow::internal::StringViewHash hash = {};
+    auto out = static_cast<size_t>(hash(id.uri));
+    ::arrow::internal::hash_combine(out, hash(id.name));
+    return out;
+  }
+
+  bool operator()(Id l, Id r) const { return l.uri == r.uri && l.name == r.name; }
+};
+
+}  // namespace
+
+struct ExtensionSet::Impl {
+  void AddUri(util::string_view uri, ExtensionSet* self) {
+    if (uris_.find(uri) != uris_.end()) return;
+
+    self->uris_.push_back(uri);
+    uris_.insert(self->uris_.back());  // lookup helper's keys should reference memory
+                                       // owned by this ExtensionSet
+  }
+
+  Status CheckHasUri(util::string_view uri) {
+    if (uris_.find(uri) != uris_.end()) return Status::OK();
+
+    return Status::Invalid(
+        "Uri ", uri,
+        " was referenced by an extension but was not declared in the ExtensionSet.");
+  }
+
+  uint32_t EncodeType(Id id, const std::shared_ptr<DataType>& type, bool is_variation,
+                      ExtensionSet* self) {
+    // note: at this point we're guaranteed to have an Id which points to memory owned by
+    // the set's registry.
+    AddUri(id.uri, self);
+    auto it_success = types_.emplace(id, static_cast<uint32_t>(types_.size()));
+
+    if (it_success.second) {
+      DCHECK_EQ(self->type_ids_.size(), self->types_.size());
+      self->type_ids_.push_back(id);
+      self->types_.push_back(type);
+      self->type_is_variation_.push_back(is_variation);
+    }
+
+    return it_success.first->second;
+  }
+
+  uint32_t EncodeFunction(Id id, util::string_view function_name, ExtensionSet* self) {
+    // note: at this point we're guaranteed to have an Id which points to memory owned by
+    // the set's registry.
+    AddUri(id.uri, self);
+    auto it_success = functions_.emplace(id, static_cast<uint32_t>(functions_.size()));
+
+    if (it_success.second) {
+      DCHECK_EQ(self->function_ids_.size(), self->function_names_.size());
+      self->function_ids_.push_back(id);
+      self->function_names_.push_back(function_name);
+    }
+
+    return it_success.first->second;
+  }
+
+  std::unordered_set<util::string_view, ::arrow::internal::StringViewHash> uris_;
+  std::unordered_map<Id, uint32_t, IdHashEq, IdHashEq> types_, functions_;
+};
+
+ExtensionSet::ExtensionSet(ExtensionIdRegistry* registry)
+    : registry_(registry), impl_(new Impl(), [](Impl* impl) { delete impl; }) {}
+
+Result<ExtensionSet> ExtensionSet::Make(std::vector<util::string_view> uris,
+                                        std::vector<Id> type_ids,
+                                        std::vector<bool> type_is_variation,
+                                        std::vector<Id> function_ids,
+                                        ExtensionIdRegistry* registry) {
+  ExtensionSet set;
+  set.registry_ = registry;
+
+  // TODO(bkietz) move this into the registry as registry->OwnUris(&uris) or so
+  std::unordered_set<util::string_view, ::arrow::internal::StringViewHash>
+      uris_owned_by_registry;
+  for (util::string_view uri : registry->Uris()) {
+    uris_owned_by_registry.insert(uri);
+  }
+
+  for (auto& uri : uris) {
+    if (uri.empty()) continue;
+    auto it = uris_owned_by_registry.find(uri);
+    if (it == uris_owned_by_registry.end()) {
+      return Status::KeyError("Uri '", uri, "' not found in registry");
+    }
+    uri = *it;  // Ensure uris point into the registry's memory
+    set.impl_->AddUri(*it, &set);
+  }
+
+  if (type_ids.size() != type_is_variation.size()) {
+    return Status::Invalid("Received ", type_ids.size(), " type ids but a ",
+                           type_is_variation.size(), "-long is_variation vector");
+  }
+
+  set.types_.resize(type_ids.size());
+
+  for (size_t i = 0; i < type_ids.size(); ++i) {
+    if (type_ids[i].empty()) continue;
+    RETURN_NOT_OK(set.impl_->CheckHasUri(type_ids[i].uri));
+
+    if (auto rec = registry->GetType(type_ids[i], type_is_variation[i])) {
+      set.types_[i] = rec->type;
+      type_ids[i] = rec->id;  // use Id which references memory owned by the registry
+      continue;
+    }
+    return Status::Invalid("Type", (type_is_variation[i] ? " variation" : ""), " ",
+                           type_ids[i].uri, "#", type_ids[i].name, " not found");
+  }
+
+  set.function_names_.resize(function_ids.size());
+
+  for (size_t i = 0; i < function_ids.size(); ++i) {
+    if (function_ids[i].empty()) continue;
+    RETURN_NOT_OK(set.impl_->CheckHasUri(function_ids[i].uri));
+
+    if (auto rec = registry->GetFunction(function_ids[i])) {
+      set.function_names_[i] = rec->function_name;
+      function_ids[i] = rec->id;  // use Id which references memory owned by the registry
+      continue;
+    }
+    return Status::Invalid("Function ", function_ids[i].uri, "#", type_ids[i].name,
+                           " not found");
+  }
+
+  set.function_ids_ = std::move(function_ids);
+  set.type_ids_ = std::move(type_ids);
+  set.type_is_variation_ = std::move(type_is_variation);
+  set.uris_ = std::move(uris);
+
+  return std::move(set);
+}
+
+Result<uint32_t> ExtensionSet::EncodeType(const DataType& type) {
+  if (auto rec = registry_->GetType(type)) {
+    return impl_->EncodeType(rec->id, rec->type, rec->is_variation, this);
+  }
+  return Status::KeyError("type ", type.ToString(), " not found in the registry");
+}
+
+Result<uint32_t> ExtensionSet::EncodeFunction(util::string_view function_name) {
+  if (auto rec = registry_->GetFunction(function_name)) {
+    return impl_->EncodeFunction(rec->id, rec->function_name, this);
+  }
+  return Status::KeyError("function ", function_name, " not found in the registry");
+}
+
+template <typename KeyToIndex, typename Key>
+const int* GetIndex(const KeyToIndex& key_to_index, const Key& key) {
+  auto it = key_to_index.find(key);
+  if (it == key_to_index.end()) return nullptr;
+  return &it->second;
+}
+
+ExtensionIdRegistry* default_extension_id_registry() {
+  static struct Impl : ExtensionIdRegistry {
+    Impl() {
+      struct TypeName {
+        std::shared_ptr<DataType> type;
+        util::string_view name;
+      };
+
+      for (TypeName e : {
+               TypeName{uint8(), "u8"},
+               TypeName{uint16(), "u16"},
+               TypeName{uint32(), "u32"},
+               TypeName{uint64(), "u64"},
+           }) {
+        DCHECK_OK(RegisterType({kArrowExtTypesUri, e.name}, std::move(e.type),
+                               /*is_variation=*/true));
+      }
+
+      for (TypeName e : {
+               TypeName{null(), "null"},
+           }) {
+        DCHECK_OK(RegisterType({kArrowExtTypesUri, e.name}, std::move(e.type),
+                               /*is_variation=*/false));
+      }
+
+      for (util::string_view name : {
+               "add",
+           }) {
+        DCHECK_OK(RegisterFunction({kArrowExtTypesUri, name}, name.to_string()));
+      }
+    }
+
+    std::vector<util::string_view> Uris() const override {
+      return {uris_.begin(), uris_.end()};
+    }
+
+    util::optional<TypeRecord> GetType(const DataType& type) const override {
+      if (auto index = GetIndex(type_to_index_, &type)) {
+        return TypeRecord{type_ids_[*index], types_[*index], type_is_variation_[*index]};
+      }
+      return {};
+    }
+
+    util::optional<TypeRecord> GetType(Id id, bool is_variation) const override {
+      if (auto index =
+              GetIndex(is_variation ? variation_id_to_index_ : id_to_index_, id)) {
+        return TypeRecord{type_ids_[*index], types_[*index], type_is_variation_[*index]};
+      }
+      return {};
+    }
+
+    Status RegisterType(Id id, std::shared_ptr<DataType> type,
+                        bool is_variation) override {
+      DCHECK_EQ(type_ids_.size(), types_.size());
+      DCHECK_EQ(type_ids_.size(), type_is_variation_.size());
+
+      Id copied_id{*uris_.emplace(id.uri.to_string()).first,
+                   *names_.emplace(id.name.to_string()).first};
+
+      auto index = static_cast<int>(type_ids_.size());
+
+      auto* id_to_index = is_variation ? &variation_id_to_index_ : &id_to_index_;
+      auto it_success = id_to_index->emplace(copied_id, index);
+
+      if (!it_success.second) {
+        return Status::Invalid("Type id was already registered");
+      }
+
+      if (!type_to_index_.emplace(type.get(), index).second) {
+        id_to_index->erase(it_success.first);
+        return Status::Invalid("Type was already registered");
+      }
+
+      type_ids_.push_back(copied_id);
+      types_.push_back(std::move(type));
+      type_is_variation_.push_back(is_variation);
+      return Status::OK();
+    }
+
+    util::optional<FunctionRecord> GetFunction(
+        util::string_view arrow_function_name) const override {
+      if (auto index = GetIndex(function_name_to_index_, arrow_function_name)) {
+        return FunctionRecord{function_ids_[*index], *function_name_ptrs_[*index]};
+      }
+      return {};
+    }
+
+    util::optional<FunctionRecord> GetFunction(Id id) const override {
+      if (auto index = GetIndex(function_id_to_index_, id)) {
+        return FunctionRecord{function_ids_[*index], *function_name_ptrs_[*index]};
+      }
+      return {};
+    }
+
+    Status RegisterFunction(Id id, std::string arrow_function_name) override {
+      DCHECK_EQ(function_ids_.size(), function_name_ptrs_.size());
+
+      Id copied_id{*uris_.emplace(id.uri.to_string()).first,
+                   *names_.emplace(id.name.to_string()).first};
+
+      const std::string& copied_function_name{
+          *function_names_.emplace(std::move(arrow_function_name)).first};
+
+      auto index = static_cast<int>(function_ids_.size());
+
+      auto it_success = function_id_to_index_.emplace(copied_id, index);
+
+      if (!it_success.second) {
+        return Status::Invalid("Function id was already registered");
+      }
+
+      if (!function_name_to_index_.emplace(copied_function_name, index).second) {
+        function_id_to_index_.erase(it_success.first);
+        return Status::Invalid("Function name was already registered");
+      }
+
+      function_name_ptrs_.push_back(&copied_function_name);
+      function_ids_.push_back(copied_id);
+      return Status::OK();
+    }
+
+    // owning storage of uris, names, (arrow::)function_names, types
+    //    note that storing strings like this is safe since references into an
+    //    unordered_set are not invalidated on insertion
+    std::unordered_set<std::string> uris_, names_, function_names_;
+    DataTypeVector types_;
+    std::vector<bool> type_is_variation_;
+
+    // non-owning lookup helpers
+    std::vector<Id> type_ids_, function_ids_;
+    std::unordered_map<Id, int, IdHashEq, IdHashEq> id_to_index_, variation_id_to_index_;
+    std::unordered_map<const DataType*, int, TypePtrHashEq, TypePtrHashEq> type_to_index_;
+
+    std::vector<const std::string*> function_name_ptrs_;
+    std::unordered_map<Id, int, IdHashEq, IdHashEq> function_id_to_index_;
+    std::unordered_map<util::string_view, int, ::arrow::internal::StringViewHash>
+        function_name_to_index_;
+  } impl_;
+
+  return &impl_;
+}
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/extension_set.h b/cpp/src/arrow/engine/substrait/extension_set.h
new file mode 100644
index 000000000000..e9ea80a00435
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/extension_set.h
@@ -0,0 +1,137 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// This API is EXPERIMENTAL.
+
+#pragma once
+
+#include <vector>
+
+#include "arrow/engine/visibility.h"
+#include "arrow/type_fwd.h"
+#include "arrow/util/optional.h"
+#include "arrow/util/string_view.h"
+
+namespace arrow {
+namespace engine {
+
+/// A mapping from arrow types and functions to the (uri, name) which identifies
+/// the corresponding substrait extension. Substrait types and variations must be
+/// registered with their corresponding arrow::DataType before they can be used!
+class ARROW_ENGINE_EXPORT ExtensionIdRegistry {
+ public:
+  /// All uris registered in this ExtensionIdRegistry
+  virtual std::vector<util::string_view> Uris() const = 0;
+
+  struct Id {
+    util::string_view uri, name;
+
+    bool empty() const { return uri.empty() && name.empty(); }
+  };
+
+  struct TypeRecord {
+    Id id;
+    const std::shared_ptr<DataType>& type;
+    bool is_variation;
+  };
+  virtual util::optional<TypeRecord> GetType(const DataType&) const = 0;
+  virtual util::optional<TypeRecord> GetType(Id, bool is_variation) const = 0;
+  virtual Status RegisterType(Id, std::shared_ptr<DataType>, bool is_variation) = 0;
+
+  // FIXME some functions will not be simple enough to convert without access to their
+  // arguments/options. For example is_in embeds the set in options rather than using an
+  // argument:
+  //     is_in(x, SetLookupOptions(set)) <-> (k...Uri, "is_in")(x, set)
+  //
+  // ... for another example, depending on the value of the first argument to
+  // substrait::add it either corresponds to arrow::add or arrow::add_checked
+  struct FunctionRecord {
+    Id id;
+    const std::string& function_name;
+  };
+  virtual util::optional<FunctionRecord> GetFunction(Id) const = 0;
+  virtual util::optional<FunctionRecord> GetFunction(
+      util::string_view arrow_function_name) const = 0;
+  virtual Status RegisterFunction(Id, std::string arrow_function_name) = 0;
+};
+
+constexpr util::string_view kArrowExtTypesUri =
+    "https://github.com/apache/arrow/blob/master/format/substrait/"
+    "extension_types.yaml";
+
+ARROW_ENGINE_EXPORT ExtensionIdRegistry* default_extension_id_registry();
+
+/// A subset of an ExtensionIdRegistry with extensions identifiable by an integer.
+///
+/// ExtensionSet does not own strings; it only refers to strings in an
+/// ExtensionIdRegistry.
+class ARROW_ENGINE_EXPORT ExtensionSet {
+ public:
+  using Id = ExtensionIdRegistry::Id;
+
+  /// Construct an empty ExtensionSet to be populated during serialization.
+  explicit ExtensionSet(ExtensionIdRegistry* = default_extension_id_registry());
+  ARROW_DEFAULT_MOVE_AND_ASSIGN(ExtensionSet);
+
+  /// Construct an ExtensionSet with explicit extension ids for efficient referencing
+  /// during deserialization. Note that input vectors need not be densely packed; an empty
+  /// (default constructed) Id may be used as a placeholder to indicate an unused
+  /// _anchor/_reference. This factory will be used to wrap the extensions declared in a
+  /// substrait::Plan before deserializing the plan's relations.
+  ///
+  /// Views will be replaced with equivalent views pointing to memory owned by the
+  /// registry.
+  static Result<ExtensionSet> Make(
+      std::vector<util::string_view> uris, std::vector<Id> type_ids,
+      std::vector<bool> type_is_variation, std::vector<Id> function_ids,
+      ExtensionIdRegistry* = default_extension_id_registry());
+
+  // index in these vectors == value of _anchor/_reference fields
+  /// FIXME this assumes that _anchor/_references won't be huge, which is not guaranteed.
+  /// Could it be?
+  const std::vector<util::string_view>& uris() const { return uris_; }
+
+  const DataTypeVector& types() const { return types_; }
+  const std::vector<Id>& type_ids() const { return type_ids_; }
+  bool type_is_variation(uint32_t i) const { return type_is_variation_[i]; }
+
+  /// Encode a type, looking it up first in this set's ExtensionIdRegistry.
+  /// If no type is found, an error will be raised.
+  Result<uint32_t> EncodeType(const DataType& type);
+
+  const std::vector<Id>& function_ids() const { return function_ids_; }
+  const std::vector<util::string_view>& function_names() const { return function_names_; }
+
+  Result<uint32_t> EncodeFunction(util::string_view function_name);
+
+ private:
+  ExtensionIdRegistry* registry_;
+  std::vector<util::string_view> uris_;
+  DataTypeVector types_;
+  std::vector<Id> type_ids_;
+  std::vector<bool> type_is_variation_;
+
+  std::vector<Id> function_ids_;
+  std::vector<util::string_view> function_names_;
+
+  // pimpl pattern to hide lookup details
+  struct Impl;
+  std::unique_ptr<Impl, void (*)(Impl*)> impl_;
+};
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc
new file mode 100644
index 000000000000..32de8980e3ed
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/extension_types.cc
@@ -0,0 +1,151 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/engine/substrait/extension_types.h"
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "arrow/engine/simple_extension_type_internal.h"
+#include "arrow/util/hash_util.h"
+#include "arrow/util/hashing.h"
+#include "arrow/util/string_view.h"
+
+namespace arrow {
+
+using internal::DataMember;
+using internal::MakeProperties;
+
+namespace engine {
+namespace {
+
+constexpr util::string_view kUuidExtensionName = "uuid";
+struct UuidExtensionParams {};
+std::shared_ptr<DataType> UuidGetStorage(const UuidExtensionParams&) {
+  return fixed_size_binary(16);
+}
+static auto kUuidExtensionParamsProperties = MakeProperties();
+
+using UuidType = SimpleExtensionType<kUuidExtensionName, UuidExtensionParams,
+                                     decltype(kUuidExtensionParamsProperties),
+                                     &kUuidExtensionParamsProperties, UuidGetStorage>;
+
+constexpr util::string_view kFixedCharExtensionName = "fixed_char";
+struct FixedCharExtensionParams {
+  int32_t length;
+};
+std::shared_ptr<DataType> FixedCharGetStorage(const FixedCharExtensionParams& params) {
+  return fixed_size_binary(params.length);
+}
+static auto kFixedCharExtensionParamsProperties =
+    MakeProperties(DataMember("length", &FixedCharExtensionParams::length));
+
+using FixedCharType =
+    SimpleExtensionType<kFixedCharExtensionName, FixedCharExtensionParams,
+                        decltype(kFixedCharExtensionParamsProperties),
+                        &kFixedCharExtensionParamsProperties, FixedCharGetStorage>;
+
+constexpr util::string_view kVarCharExtensionName = "varchar";
+struct VarCharExtensionParams {
+  int32_t length;
+};
+std::shared_ptr<DataType> VarCharGetStorage(const VarCharExtensionParams&) {
+  return utf8();
+}
+static auto kVarCharExtensionParamsProperties =
+    MakeProperties(DataMember("length", &VarCharExtensionParams::length));
+
+using VarCharType =
+    SimpleExtensionType<kVarCharExtensionName, VarCharExtensionParams,
+                        decltype(kVarCharExtensionParamsProperties),
+                        &kVarCharExtensionParamsProperties, VarCharGetStorage>;
+
+constexpr util::string_view kIntervalYearExtensionName = "interval_year";
+struct IntervalYearExtensionParams {};
+std::shared_ptr<DataType> IntervalYearGetStorage(const IntervalYearExtensionParams&) {
+  return fixed_size_list(int32(), 2);
+}
+static auto kIntervalYearExtensionParamsProperties = MakeProperties();
+
+using IntervalYearType =
+    SimpleExtensionType<kIntervalYearExtensionName, IntervalYearExtensionParams,
+                        decltype(kIntervalYearExtensionParamsProperties),
+                        &kIntervalYearExtensionParamsProperties, IntervalYearGetStorage>;
+
+constexpr util::string_view kIntervalDayExtensionName = "interval_day";
+struct IntervalDayExtensionParams {};
+std::shared_ptr<DataType> IntervalDayGetStorage(const IntervalDayExtensionParams&) {
+  return fixed_size_list(int32(), 2);
+}
+static auto kIntervalDayExtensionParamsProperties = MakeProperties();
+
+using IntervalDayType =
+    SimpleExtensionType<kIntervalDayExtensionName, IntervalDayExtensionParams,
+                        decltype(kIntervalDayExtensionParamsProperties),
+                        &kIntervalDayExtensionParamsProperties, IntervalDayGetStorage>;
+
+}  // namespace
+
+std::shared_ptr<DataType> uuid() { return UuidType::Make({}); }
+
+std::shared_ptr<DataType> fixed_char(int32_t length) {
+  return FixedCharType::Make({length});
+}
+
+std::shared_ptr<DataType> varchar(int32_t length) { return VarCharType::Make({length}); }
+
+std::shared_ptr<DataType> interval_year() { return IntervalYearType::Make({}); }
+
+std::shared_ptr<DataType> interval_day() { return IntervalDayType::Make({}); }
+
+bool UnwrapUuid(const DataType& t) {
+  if (UuidType::GetIf(t)) {
+    return true;
+  }
+  return false;
+}
+
+util::optional<int32_t> UnwrapFixedChar(const DataType& t) {
+  if (auto params = FixedCharType::GetIf(t)) {
+    return params->length;
+  }
+  return util::nullopt;
+}
+
+util::optional<int32_t> UnwrapVarChar(const DataType& t) {
+  if (auto params = VarCharType::GetIf(t)) {
+    return params->length;
+  }
+  return util::nullopt;
+}
+
+bool UnwrapIntervalYear(const DataType& t) {
+  if (IntervalYearType::GetIf(t)) {
+    return true;
+  }
+  return false;
+}
+
+bool UnwrapIntervalDay(const DataType& t) {
+  if (IntervalDayType::GetIf(t)) {
+    return true;
+  }
+  return false;
+}
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h
new file mode 100644
index 000000000000..e689e94722e7
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/extension_types.h
@@ -0,0 +1,82 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// This API is EXPERIMENTAL.
+
+#pragma once
+
+#include <vector>
+
+#include "arrow/buffer.h"
+#include "arrow/compute/function.h"
+#include "arrow/engine/visibility.h"
+#include "arrow/type_fwd.h"
+#include "arrow/util/optional.h"
+#include "arrow/util/string_view.h"
+
+namespace arrow {
+namespace engine {
+
+// arrow::ExtensionTypes are provided to wrap uuid, fixed_char, varchar, interval_year,
+// and interval_day which are first-class types in substrait but do not appear in
+// the arrow type system.
+//
+// Note that these are not automatically registered with arrow::RegisterExtensionType(),
+// which means among other things that serialization of these types to IPC would fail.
+
+/// fixed_size_binary(16) for storing Universally Unique IDentifiers
+ARROW_ENGINE_EXPORT
+std::shared_ptr<DataType> uuid();
+
+/// fixed_size_binary(length) constrained to contain only valid UTF-8
+ARROW_ENGINE_EXPORT
+std::shared_ptr<DataType> fixed_char(int32_t length);
+
+/// utf8() constrained to be shorter than `length`
+ARROW_ENGINE_EXPORT
+std::shared_ptr<DataType> varchar(int32_t length);
+
+/// fixed_size_list(int32(), 2) storing a number of [years, months]
+ARROW_ENGINE_EXPORT
+std::shared_ptr<DataType> interval_year();
+
+/// fixed_size_list(int32(), 2) storing a number of [days, seconds]
+ARROW_ENGINE_EXPORT
+std::shared_ptr<DataType> interval_day();
+
+/// Return true if t is Uuid, otherwise false
+ARROW_ENGINE_EXPORT
+bool UnwrapUuid(const DataType&);
+
+/// Return FixedChar length if t is FixedChar, otherwise nullopt
+ARROW_ENGINE_EXPORT
+util::optional<int32_t> UnwrapFixedChar(const DataType&);
+
+/// Return Varchar (max) length if t is VarChar, otherwise nullopt
+ARROW_ENGINE_EXPORT
+util::optional<int32_t> UnwrapVarChar(const DataType& t);
+
+/// Return true if t is IntervalYear, otherwise false
+ARROW_ENGINE_EXPORT
+bool UnwrapIntervalYear(const DataType&);
+
+/// Return true if t is IntervalDay, otherwise false
+ARROW_ENGINE_EXPORT
+bool UnwrapIntervalDay(const DataType&);
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/plan_internal.cc b/cpp/src/arrow/engine/substrait/plan_internal.cc
new file mode 100644
index 000000000000..90fda7427137
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/plan_internal.cc
@@ -0,0 +1,162 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/engine/substrait/plan_internal.h"
+
+#include "arrow/result.h"
+#include "arrow/util/hashing.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/make_unique.h"
+#include "arrow/util/unreachable.h"
+
+namespace arrow {
+
+using internal::checked_cast;
+
+namespace engine {
+
+namespace internal {
+using ::arrow::internal::make_unique;
+}  // namespace internal
+
+Status AddExtensionSetToPlan(const ExtensionSet& ext_set, substrait::Plan* plan) {
+  plan->clear_extension_uris();
+
+  std::unordered_map<util::string_view, int, ::arrow::internal::StringViewHash> map;
+
+  auto uris = plan->mutable_extension_uris();
+  uris->Reserve(static_cast<int>(ext_set.uris().size()));
+  for (uint32_t anchor = 0; anchor < ext_set.uris().size(); ++anchor) {
+    auto uri = ext_set.uris()[anchor];
+    if (uri.empty()) continue;
+
+    auto ext_uri = internal::make_unique<substrait::extensions::SimpleExtensionURI>();
+    ext_uri->set_uri(uri.to_string());
+    ext_uri->set_extension_uri_anchor(anchor);
+    uris->AddAllocated(ext_uri.release());
+
+    map[uri] = anchor;
+  }
+
+  auto extensions = plan->mutable_extensions();
+  extensions->Reserve(
+      static_cast<int>(ext_set.type_ids().size() + ext_set.function_ids().size()));
+
+  using ExtDecl = substrait::extensions::SimpleExtensionDeclaration;
+
+  for (uint32_t anchor = 0; anchor < ext_set.type_ids().size(); ++anchor) {
+    auto id = ext_set.type_ids()[anchor];
+    if (id.empty()) continue;
+
+    auto ext_decl = internal::make_unique<ExtDecl>();
+
+    if (ext_set.type_is_variation(anchor)) {
+      auto type_var = internal::make_unique<ExtDecl::ExtensionTypeVariation>();
+      type_var->set_extension_uri_reference(map[id.uri]);
+      type_var->set_type_variation_anchor(anchor);
+      type_var->set_name(id.name.to_string());
+      ext_decl->set_allocated_extension_type_variation(type_var.release());
+    } else {
+      auto type = internal::make_unique<ExtDecl::ExtensionType>();
+      type->set_extension_uri_reference(map[id.uri]);
+      type->set_type_anchor(anchor);
+      type->set_name(id.name.to_string());
+      ext_decl->set_allocated_extension_type(type.release());
+    }
+
+    extensions->AddAllocated(ext_decl.release());
+  }
+
+  for (uint32_t anchor = 0; anchor < ext_set.function_ids().size(); ++anchor) {
+    auto id = ext_set.function_ids()[anchor];
+    if (id.empty()) continue;
+
+    auto fn = internal::make_unique<ExtDecl::ExtensionFunction>();
+    fn->set_extension_uri_reference(map[id.uri]);
+    fn->set_function_anchor(anchor);
+    fn->set_name(id.name.to_string());
+
+    auto ext_decl = internal::make_unique<ExtDecl>();
+    ext_decl->set_allocated_extension_function(fn.release());
+    extensions->AddAllocated(ext_decl.release());
+  }
+
+  return Status::OK();
+}
+
+namespace {
+template <typename Element, typename T>
+void SetElement(size_t i, const Element& element, std::vector<T>* vector) {
+  DCHECK_LE(i, 1 << 20);
+  if (i >= vector->size()) {
+    vector->resize(i + 1);
+  }
+  (*vector)[i] = static_cast<T>(element);
+}
+}  // namespace
+
+Result<ExtensionSet> GetExtensionSetFromPlan(const substrait::Plan& plan,
+                                             ExtensionIdRegistry* registry) {
+  std::vector<util::string_view> uris;
+  for (const auto& uri : plan.extension_uris()) {
+    SetElement(uri.extension_uri_anchor(), uri.uri(), &uris);
+  }
+
+  // NOTE: it's acceptable to use views to memory owned by plan; ExtensionSet::Make
+  // will only store views to memory owned by registry.
+
+  using Id = ExtensionSet::Id;
+
+  std::vector<Id> type_ids, function_ids;
+  std::vector<bool> type_is_variation;
+  for (const auto& ext : plan.extensions()) {
+    switch (ext.mapping_type_case()) {
+      case substrait::extensions::SimpleExtensionDeclaration::kExtensionTypeVariation: {
+        const auto& type_var = ext.extension_type_variation();
+        util::string_view uri = uris[type_var.extension_uri_reference()];
+        SetElement(type_var.type_variation_anchor(), Id{uri, type_var.name()}, &type_ids);
+        SetElement(type_var.type_variation_anchor(), true, &type_is_variation);
+        break;
+      }
+
+      case substrait::extensions::SimpleExtensionDeclaration::kExtensionType: {
+        const auto& type = ext.extension_type();
+        util::string_view uri = uris[type.extension_uri_reference()];
+        SetElement(type.type_anchor(), Id{uri, type.name()}, &type_ids);
+        SetElement(type.type_anchor(), false, &type_is_variation);
+        break;
+      }
+
+      case substrait::extensions::SimpleExtensionDeclaration::kExtensionFunction: {
+        const auto& fn = ext.extension_function();
+        util::string_view uri = uris[fn.extension_uri_reference()];
+        SetElement(fn.function_anchor(), Id{uri, fn.name()}, &function_ids);
+        break;
+      }
+
+      default:
+        Unreachable();
+    }
+  }
+
+  return ExtensionSet::Make(std::move(uris), std::move(type_ids),
+                            std::move(type_is_variation), std::move(function_ids),
+                            registry);
+}
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/plan_internal.h b/cpp/src/arrow/engine/substrait/plan_internal.h
new file mode 100644
index 000000000000..5819ea209f2e
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/plan_internal.h
@@ -0,0 +1,39 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// This API is EXPERIMENTAL.
+
+#pragma once
+
+#include "arrow/engine/substrait/extension_set.h"
+#include "arrow/engine/visibility.h"
+#include "arrow/type_fwd.h"
+
+#include "generated/substrait/plan.pb.h"  // IWYU pragma: export
+
+namespace arrow {
+namespace engine {
+
+ARROW_ENGINE_EXPORT
+Status AddExtensionSetToPlan(const ExtensionSet&, substrait::Plan*);
+
+ARROW_ENGINE_EXPORT
+Result<ExtensionSet> GetExtensionSetFromPlan(
+    const substrait::Plan&, ExtensionIdRegistry* = default_extension_id_registry());
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/relation_internal.cc b/cpp/src/arrow/engine/substrait/relation_internal.cc
new file mode 100644
index 000000000000..75dc0ecff76b
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/relation_internal.cc
@@ -0,0 +1,186 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/engine/substrait/relation_internal.h"
+
+#include "arrow/compute/api_scalar.h"
+#include "arrow/compute/exec/options.h"
+#include "arrow/dataset/file_parquet.h"
+#include "arrow/dataset/plan.h"
+#include "arrow/dataset/scanner.h"
+#include "arrow/engine/substrait/expression_internal.h"
+#include "arrow/engine/substrait/type_internal.h"
+#include "arrow/filesystem/localfs.h"
+
+namespace arrow {
+namespace engine {
+
+template <typename RelMessage>
+Status CheckRelCommon(const RelMessage& rel) {
+  if (rel.has_common()) {
+    if (rel.common().has_emit()) {
+      return Status::NotImplemented("substrait::RelCommon::Emit");
+    }
+    if (rel.common().has_hint()) {
+      return Status::NotImplemented("substrait::RelCommon::Hint");
+    }
+    if (rel.common().has_advanced_extension()) {
+      return Status::NotImplemented("substrait::RelCommon::advanced_extension");
+    }
+  }
+  if (rel.has_advanced_extension()) {
+    return Status::NotImplemented("substrait AdvancedExtensions");
+  }
+  return Status::OK();
+}
+
+Result<compute::Declaration> FromProto(const substrait::Rel& rel,
+                                       const ExtensionSet& ext_set) {
+  static bool dataset_init = false;
+  if (!dataset_init) {
+    dataset_init = true;
+    dataset::internal::Initialize();
+  }
+
+  switch (rel.rel_type_case()) {
+    case substrait::Rel::RelTypeCase::kRead: {
+      const auto& read = rel.read();
+      RETURN_NOT_OK(CheckRelCommon(read));
+
+      ARROW_ASSIGN_OR_RAISE(auto base_schema, FromProto(read.base_schema(), ext_set));
+
+      auto scan_options = std::make_shared<dataset::ScanOptions>();
+
+      if (read.has_filter()) {
+        ARROW_ASSIGN_OR_RAISE(scan_options->filter, FromProto(read.filter(), ext_set));
+      }
+
+      if (read.has_projection()) {
+        return Status::NotImplemented("substrait::ReadRel::projection");
+      }
+
+      {
+        // just project all fields
+        std::vector<compute::Expression> expressions{base_schema->fields().size()};
+        for (int i = 0; i < base_schema->num_fields(); ++i) {
+          expressions[i] = compute::field_ref(i);
+        }
+        scan_options->projection =
+            compute::call("make_struct", std::move(expressions),
+                          compute::MakeStructOptions{base_schema->field_names()});
+      }
+
+      if (!read.has_local_files()) {
+        return Status::NotImplemented(
+            "substrait::ReadRel with read_type other than LocalFiles");
+      }
+
+      if (read.local_files().has_advanced_extension()) {
+        return Status::NotImplemented(
+            "substrait::ReadRel::LocalFiles::advanced_extension");
+      }
+
+      auto format = std::make_shared<dataset::ParquetFileFormat>();
+      auto filesystem = std::make_shared<fs::LocalFileSystem>();
+      std::vector<std::shared_ptr<dataset::FileFragment>> fragments;
+
+      for (const auto& item : read.local_files().items()) {
+        if (!item.has_uri_file()) {
+          return Status::NotImplemented(
+              "substrait::ReadRel::LocalFiles::FileOrFiles with "
+              "path_type other than uri_file");
+        }
+
+        if (item.format() !=
+            substrait::ReadRel::LocalFiles::FileOrFiles::FILE_FORMAT_PARQUET) {
+          return Status::NotImplemented(
+              "substrait::ReadRel::LocalFiles::FileOrFiles::format "
+              "other than FILE_FORMAT_PARQUET");
+        }
+
+        if (!util::string_view{item.uri_file()}.starts_with("file:///")) {
+          return Status::NotImplemented(
+              "substrait::ReadRel::LocalFiles::FileOrFiles::uri_file "
+              "with other than local filesystem (file:///)");
+        }
+        auto path = item.uri_file().substr(7);
+
+        ARROW_ASSIGN_OR_RAISE(auto fragment, format->MakeFragment(dataset::FileSource{
+                                                 std::move(path), filesystem}));
+        fragments.push_back(std::move(fragment));
+      }
+
+      ARROW_ASSIGN_OR_RAISE(
+          auto ds, dataset::FileSystemDataset::Make(
+                       std::move(base_schema), /*root_partition=*/compute::literal(true),
+                       std::move(format), std::move(filesystem), std::move(fragments)));
+
+      return compute::Declaration{
+          "scan", dataset::ScanNodeOptions{std::move(ds), std::move(scan_options)}};
+    }
+
+    case substrait::Rel::RelTypeCase::kFilter: {
+      const auto& filter = rel.filter();
+      RETURN_NOT_OK(CheckRelCommon(filter));
+
+      if (!filter.has_input()) {
+        return Status::Invalid("substrait::FilterRel with no input relation");
+      }
+      ARROW_ASSIGN_OR_RAISE(auto input, FromProto(filter.input(), ext_set));
+
+      if (!filter.has_condition()) {
+        return Status::Invalid("substrait::FilterRel with no condition expression");
+      }
+      ARROW_ASSIGN_OR_RAISE(auto condition, FromProto(filter.condition(), ext_set));
+
+      return compute::Declaration::Sequence({
+          std::move(input),
+          {"filter", compute::FilterNodeOptions{std::move(condition)}},
+      });
+    }
+
+    case substrait::Rel::RelTypeCase::kProject: {
+      const auto& project = rel.project();
+      RETURN_NOT_OK(CheckRelCommon(project));
+
+      if (!project.has_input()) {
+        return Status::Invalid("substrait::ProjectRel with no input relation");
+      }
+      ARROW_ASSIGN_OR_RAISE(auto input, FromProto(project.input(), ext_set));
+
+      std::vector<compute::Expression> expressions;
+      for (const auto& expr : project.expressions()) {
+        expressions.emplace_back();
+        ARROW_ASSIGN_OR_RAISE(expressions.back(), FromProto(expr, ext_set));
+      }
+
+      return compute::Declaration::Sequence({
+          std::move(input),
+          {"project", compute::ProjectNodeOptions{std::move(expressions)}},
+      });
+    }
+
+    default:
+      break;
+  }
+
+  return Status::NotImplemented("conversion to arrow::compute::Declaration from ",
+                                rel.DebugString());
+}
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/relation_internal.h b/cpp/src/arrow/engine/substrait/relation_internal.h
new file mode 100644
index 000000000000..b0e899a6af37
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/relation_internal.h
@@ -0,0 +1,37 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// This API is EXPERIMENTAL.
+
+#pragma once
+
+#include "arrow/compute/exec/exec_plan.h"
+#include "arrow/engine/substrait/extension_types.h"
+#include "arrow/engine/substrait/serde.h"
+#include "arrow/engine/visibility.h"
+#include "arrow/type_fwd.h"
+
+#include "generated/substrait/relations.pb.h"  // IWYU pragma: export
+
+namespace arrow {
+namespace engine {
+
+ARROW_ENGINE_EXPORT
+Result<compute::Declaration> FromProto(const substrait::Rel&, const ExtensionSet&);
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/serde.cc b/cpp/src/arrow/engine/substrait/serde.cc
new file mode 100644
index 000000000000..ea916d86757b
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/serde.cc
@@ -0,0 +1,232 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/engine/substrait/serde.h"
+
+#include "arrow/engine/substrait/expression_internal.h"
+#include "arrow/engine/substrait/plan_internal.h"
+#include "arrow/engine/substrait/relation_internal.h"
+#include "arrow/engine/substrait/type_internal.h"
+#include "arrow/util/string_view.h"
+
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/util/json_util.h>
+#include <google/protobuf/util/message_differencer.h>
+#include <google/protobuf/util/type_resolver_util.h>
+
+namespace arrow {
+namespace engine {
+
+Status ParseFromBufferImpl(const Buffer& buf, const std::string& full_name,
+                           google::protobuf::Message* message) {
+  google::protobuf::io::ArrayInputStream buf_stream{buf.data(),
+                                                    static_cast<int>(buf.size())};
+
+  if (message->ParseFromZeroCopyStream(&buf_stream)) {
+    return Status::OK();
+  }
+  return Status::IOError("ParseFromZeroCopyStream failed for ", full_name);
+}
+
+template <typename Message>
+Result<Message> ParseFromBuffer(const Buffer& buf) {
+  Message message;
+  ARROW_RETURN_NOT_OK(
+      ParseFromBufferImpl(buf, Message::descriptor()->full_name(), &message));
+  return message;
+}
+
+Result<compute::Declaration> DeserializeRelation(const Buffer& buf,
+                                                 const ExtensionSet& ext_set) {
+  ARROW_ASSIGN_OR_RAISE(auto rel, ParseFromBuffer<substrait::Rel>(buf));
+  return FromProto(rel, ext_set);
+}
+
+Result<std::vector<compute::Declaration>> DeserializePlan(
+    const Buffer& buf, const ConsumerFactory& consumer_factory,
+    ExtensionSet* ext_set_out) {
+  ARROW_ASSIGN_OR_RAISE(auto plan, ParseFromBuffer<substrait::Plan>(buf));
+
+  ARROW_ASSIGN_OR_RAISE(auto ext_set, GetExtensionSetFromPlan(plan));
+
+  std::vector<compute::Declaration> sink_decls;
+  for (const substrait::PlanRel& plan_rel : plan.relations()) {
+    if (plan_rel.has_root()) {
+      return Status::NotImplemented("substrait::PlanRel with custom output field names");
+    }
+    ARROW_ASSIGN_OR_RAISE(auto decl, FromProto(plan_rel.rel(), ext_set));
+
+    // pipe each relation into a consuming_sink node
+    auto sink_decl = compute::Declaration::Sequence({
+        std::move(decl),
+        {"consuming_sink", compute::ConsumingSinkNodeOptions{consumer_factory()}},
+    });
+    sink_decls.push_back(std::move(sink_decl));
+  }
+
+  if (ext_set_out) {
+    *ext_set_out = std::move(ext_set);
+  }
+  return sink_decls;
+}
+
+Result<std::shared_ptr<Schema>> DeserializeSchema(const Buffer& buf,
+                                                  const ExtensionSet& ext_set) {
+  ARROW_ASSIGN_OR_RAISE(auto named_struct, ParseFromBuffer<substrait::NamedStruct>(buf));
+  return FromProto(named_struct, ext_set);
+}
+
+Result<std::shared_ptr<Buffer>> SerializeSchema(const Schema& schema,
+                                                ExtensionSet* ext_set) {
+  ARROW_ASSIGN_OR_RAISE(auto named_struct, ToProto(schema, ext_set));
+  std::string serialized = named_struct->SerializeAsString();
+  return Buffer::FromString(std::move(serialized));
+}
+
+Result<std::shared_ptr<DataType>> DeserializeType(const Buffer& buf,
+                                                  const ExtensionSet& ext_set) {
+  ARROW_ASSIGN_OR_RAISE(auto type, ParseFromBuffer<substrait::Type>(buf));
+  ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(type, ext_set));
+  return std::move(type_nullable.first);
+}
+
+Result<std::shared_ptr<Buffer>> SerializeType(const DataType& type,
+                                              ExtensionSet* ext_set) {
+  ARROW_ASSIGN_OR_RAISE(auto st_type, ToProto(type, /*nullable=*/true, ext_set));
+  std::string serialized = st_type->SerializeAsString();
+  return Buffer::FromString(std::move(serialized));
+}
+
+Result<compute::Expression> DeserializeExpression(const Buffer& buf,
+                                                  const ExtensionSet& ext_set) {
+  ARROW_ASSIGN_OR_RAISE(auto expr, ParseFromBuffer<substrait::Expression>(buf));
+  return FromProto(expr, ext_set);
+}
+
+Result<std::shared_ptr<Buffer>> SerializeExpression(const compute::Expression& expr,
+                                                    ExtensionSet* ext_set) {
+  ARROW_ASSIGN_OR_RAISE(auto st_expr, ToProto(expr, ext_set));
+  std::string serialized = st_expr->SerializeAsString();
+  return Buffer::FromString(std::move(serialized));
+}
+
+namespace internal {
+
+template <typename Message>
+static Status CheckMessagesEquivalent(const Buffer& l_buf, const Buffer& r_buf) {
+  ARROW_ASSIGN_OR_RAISE(auto l, ParseFromBuffer<Message>(l_buf));
+  ARROW_ASSIGN_OR_RAISE(auto r, ParseFromBuffer<Message>(r_buf));
+
+  using google::protobuf::util::MessageDifferencer;
+
+  std::string out;
+  google::protobuf::io::StringOutputStream out_stream{&out};
+  MessageDifferencer::StreamReporter reporter{&out_stream};
+
+  MessageDifferencer differencer;
+  differencer.set_message_field_comparison(MessageDifferencer::EQUIVALENT);
+  differencer.ReportDifferencesTo(&reporter);
+
+  if (differencer.Compare(l, r)) {
+    return Status::OK();
+  }
+  return Status::Invalid("Messages were not equivalent: ", out);
+}
+
+Status CheckMessagesEquivalent(util::string_view message_name, const Buffer& l_buf,
+                               const Buffer& r_buf) {
+  if (message_name == "Type") {
+    return CheckMessagesEquivalent<substrait::Type>(l_buf, r_buf);
+  }
+
+  if (message_name == "NamedStruct") {
+    return CheckMessagesEquivalent<substrait::NamedStruct>(l_buf, r_buf);
+  }
+
+  if (message_name == "Schema") {
+    return Status::Invalid(
+        "There is no substrait message named Schema. The substrait message type which "
+        "corresponds to Schemas is NamedStruct");
+  }
+
+  if (message_name == "Expression") {
+    return CheckMessagesEquivalent<substrait::Expression>(l_buf, r_buf);
+  }
+
+  if (message_name == "Rel") {
+    return CheckMessagesEquivalent<substrait::Rel>(l_buf, r_buf);
+  }
+
+  if (message_name == "Relation") {
+    return Status::Invalid(
+        "There is no substrait message named Relation. You probably meant \"Rel\"");
+  }
+
+  return Status::Invalid("Unsupported message name ", message_name,
+                         " for CheckMessagesEquivalent");
+}
+
+inline google::protobuf::util::TypeResolver* GetGeneratedTypeResolver() {
+  static std::unique_ptr<google::protobuf::util::TypeResolver> type_resolver;
+  if (!type_resolver) {
+    type_resolver.reset(google::protobuf::util::NewTypeResolverForDescriptorPool(
+        /*url_prefix=*/"", google::protobuf::DescriptorPool::generated_pool()));
+  }
+  return type_resolver.get();
+}
+
+Result<std::shared_ptr<Buffer>> SubstraitFromJSON(util::string_view type_name,
+                                                  util::string_view json) {
+  std::string type_url = "/substrait." + type_name.to_string();
+
+  google::protobuf::io::ArrayInputStream json_stream{json.data(),
+                                                     static_cast<int>(json.size())};
+
+  std::string out;
+  google::protobuf::io::StringOutputStream out_stream{&out};
+
+  auto status = google::protobuf::util::JsonToBinaryStream(
+      GetGeneratedTypeResolver(), type_url, &json_stream, &out_stream);
+
+  if (!status.ok()) {
+    return Status::Invalid("JsonToBinaryStream returned ", status);
+  }
+  return Buffer::FromString(std::move(out));
+}
+
+Result<std::string> SubstraitToJSON(util::string_view type_name, const Buffer& buf) {
+  std::string type_url = "/substrait." + type_name.to_string();
+
+  google::protobuf::io::ArrayInputStream buf_stream{buf.data(),
+                                                    static_cast<int>(buf.size())};
+
+  std::string out;
+  google::protobuf::io::StringOutputStream out_stream{&out};
+
+  auto status = google::protobuf::util::BinaryToJsonStream(
+      GetGeneratedTypeResolver(), type_url, &buf_stream, &out_stream);
+  if (!status.ok()) {
+    return Status::Invalid("BinaryToJsonStream returned ", status);
+  }
+  return out;
+}
+
+}  // namespace internal
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h
new file mode 100644
index 000000000000..a9f0fcfca5ac
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/serde.h
@@ -0,0 +1,79 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// This API is EXPERIMENTAL.
+
+#pragma once
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "arrow/buffer.h"
+#include "arrow/compute/exec/exec_plan.h"
+#include "arrow/compute/exec/options.h"
+#include "arrow/engine/substrait/extension_set.h"
+#include "arrow/engine/visibility.h"
+#include "arrow/result.h"
+#include "arrow/util/string_view.h"
+
+namespace arrow {
+namespace engine {
+
+using ConsumerFactory = std::function<std::shared_ptr<compute::SinkNodeConsumer>()>;
+
+ARROW_ENGINE_EXPORT Result<std::vector<compute::Declaration>> DeserializePlan(
+    const Buffer&, const ConsumerFactory&, ExtensionSet* ext_set = NULLPTR);
+
+ARROW_ENGINE_EXPORT
+Result<std::shared_ptr<DataType>> DeserializeType(const Buffer&, const ExtensionSet&);
+
+ARROW_ENGINE_EXPORT
+Result<std::shared_ptr<Buffer>> SerializeType(const DataType&, ExtensionSet*);
+
+ARROW_ENGINE_EXPORT
+Result<std::shared_ptr<Schema>> DeserializeSchema(const Buffer&, const ExtensionSet&);
+
+ARROW_ENGINE_EXPORT
+Result<std::shared_ptr<Buffer>> SerializeSchema(const Schema&, ExtensionSet*);
+
+ARROW_ENGINE_EXPORT
+Result<compute::Expression> DeserializeExpression(const Buffer&, const ExtensionSet&);
+
+ARROW_ENGINE_EXPORT
+Result<std::shared_ptr<Buffer>> SerializeExpression(const compute::Expression&,
+                                                    ExtensionSet*);
+
+ARROW_ENGINE_EXPORT Result<compute::Declaration> DeserializeRelation(const Buffer&,
+                                                                     const ExtensionSet&);
+
+namespace internal {
+
+ARROW_ENGINE_EXPORT
+Status CheckMessagesEquivalent(util::string_view message_name, const Buffer&,
+                               const Buffer&);
+
+ARROW_ENGINE_EXPORT
+Result<std::shared_ptr<Buffer>> SubstraitFromJSON(util::string_view type_name,
+                                                  util::string_view json);
+
+ARROW_ENGINE_EXPORT
+Result<std::string> SubstraitToJSON(util::string_view type_name, const Buffer& buf);
+
+}  // namespace internal
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc
new file mode 100644
index 000000000000..983ff6d5a3d0
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/serde_test.cc
@@ -0,0 +1,749 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/engine/substrait/serde.h"
+
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/util/json_util.h>
+#include <google/protobuf/util/type_resolver_util.h>
+#include <gtest/gtest.h>
+
+#include "arrow/compute/exec/expression_internal.h"
+#include "arrow/dataset/file_base.h"
+#include "arrow/dataset/scanner.h"
+#include "arrow/engine/substrait/extension_types.h"
+#include "arrow/testing/gtest_util.h"
+#include "arrow/testing/matchers.h"
+#include "arrow/util/key_value_metadata.h"
+
+using testing::ElementsAre;
+using testing::Eq;
+using testing::HasSubstr;
+
+namespace arrow {
+
+using internal::checked_cast;
+
+namespace engine {
+
+const std::shared_ptr<Schema> kBoringSchema = schema({
+    field("bool", boolean()),
+    field("i8", int8()),
+    field("i32", int32()),
+    field("i32_req", int32(), /*nullable=*/false),
+    field("u32", uint32()),
+    field("i64", int64()),
+    field("f32", float32()),
+    field("f32_req", float32(), /*nullable=*/false),
+    field("f64", float64()),
+    field("date64", date64()),
+    field("str", utf8()),
+    field("list_i32", list(int32())),
+    field("struct", struct_({
+                        field("i32", int32()),
+                        field("str", utf8()),
+                        field("struct_i32_str",
+                              struct_({field("i32", int32()), field("str", utf8())})),
+                    })),
+    field("list_struct", list(struct_({
+                             field("i32", int32()),
+                             field("str", utf8()),
+                             field("struct_i32_str", struct_({field("i32", int32()),
+                                                              field("str", utf8())})),
+                         }))),
+    field("dict_str", dictionary(int32(), utf8())),
+    field("dict_i32", dictionary(int32(), int32())),
+    field("ts_ns", timestamp(TimeUnit::NANO)),
+});
+
+std::shared_ptr<DataType> StripFieldNames(std::shared_ptr<DataType> type) {
+  if (type->id() == Type::STRUCT) {
+    FieldVector fields(type->num_fields());
+    for (int i = 0; i < type->num_fields(); ++i) {
+      fields[i] = type->field(i)->WithName("");
+    }
+    return struct_(std::move(fields));
+  }
+
+  if (type->id() == Type::LIST) {
+    return list(type->field(0)->WithName(""));
+  }
+
+  return type;
+}
+
+// map to an index-only field reference
+inline FieldRef BoringRef(FieldRef ref) {
+  auto path = *ref.FindOne(*kBoringSchema);
+  return {std::move(path)};
+}
+
+inline compute::Expression UseBoringRefs(const compute::Expression& expr) {
+  if (expr.literal()) return expr;
+
+  if (auto ref = expr.field_ref()) {
+    return compute::field_ref(*ref->FindOne(*kBoringSchema));
+  }
+
+  auto modified_call = *CallNotNull(expr);
+  for (auto& arg : modified_call.arguments) {
+    arg = UseBoringRefs(arg);
+  }
+  return compute::Expression{std::move(modified_call)};
+}
+
+std::shared_ptr<Buffer> SubstraitFromJSON(util::string_view type_name,
+                                          util::string_view json) {
+  auto maybe_buf = internal::SubstraitFromJSON(type_name, json);
+  DCHECK_OK(maybe_buf.status());
+  return maybe_buf.ValueOrDie();
+}
+
+std::string SubstraitToJSON(util::string_view type_name, const Buffer& buf) {
+  auto maybe_buf = internal::SubstraitToJSON(type_name, buf);
+  DCHECK_OK(maybe_buf.status());
+  return maybe_buf.ValueOrDie();
+}
+
+TEST(Substrait, SupportedTypes) {
+  auto ExpectEq = [](util::string_view json, std::shared_ptr<DataType> expected_type) {
+    ARROW_SCOPED_TRACE(json);
+
+    ExtensionSet empty;
+    auto buf = SubstraitFromJSON("Type", json);
+    ASSERT_OK_AND_ASSIGN(auto type, DeserializeType(*buf, empty));
+
+    EXPECT_EQ(*type, *expected_type);
+
+    ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type, &empty));
+    EXPECT_EQ(empty.types().size(), 0);
+
+    // FIXME chokes on NULLABILITY_UNSPECIFIED
+    // EXPECT_THAT(internal::CheckMessagesEquivalent("Type", *buf, *serialized), Ok());
+
+    ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized, empty));
+
+    EXPECT_EQ(*roundtripped, *expected_type);
+  };
+
+  ExpectEq(R"({"bool": {}})", boolean());
+
+  ExpectEq(R"({"i8": {}})", int8());
+  ExpectEq(R"({"i16": {}})", int16());
+  ExpectEq(R"({"i32": {}})", int32());
+  ExpectEq(R"({"i64": {}})", int64());
+
+  ExpectEq(R"({"fp32": {}})", float32());
+  ExpectEq(R"({"fp64": {}})", float64());
+
+  ExpectEq(R"({"string": {}})", utf8());
+  ExpectEq(R"({"binary": {}})", binary());
+
+  ExpectEq(R"({"timestamp": {}})", timestamp(TimeUnit::MICRO));
+  ExpectEq(R"({"date": {}})", date64());
+  ExpectEq(R"({"time": {}})", time64(TimeUnit::MICRO));
+  ExpectEq(R"({"timestamp_tz": {}})", timestamp(TimeUnit::MICRO, "UTC"));
+  ExpectEq(R"({"interval_year": {}})", interval_year());
+  ExpectEq(R"({"interval_day": {}})", interval_day());
+
+  ExpectEq(R"({"uuid": {}})", uuid());
+
+  ExpectEq(R"({"fixed_char": {"length": 32}})", fixed_char(32));
+  ExpectEq(R"({"varchar": {"length": 1024}})", varchar(1024));
+  ExpectEq(R"({"fixed_binary": {"length": 32}})", fixed_size_binary(32));
+
+  ExpectEq(R"({"decimal": {"precision": 27, "scale": 5}})", decimal128(27, 5));
+
+  ExpectEq(R"({"struct": {
+    "types": [
+      {"i64": {}},
+      {"list": {"type": {"string":{}} }}
+    ]
+  }})",
+           struct_({
+               field("", int64()),
+               field("", list(utf8())),
+           }));
+}
+
+TEST(Substrait, SupportedExtensionTypes) {
+  ExtensionSet ext_set;
+
+  for (auto expected_type : {
+           null(),
+           uint8(),
+           uint16(),
+           uint32(),
+           uint64(),
+       }) {
+    auto anchor = ext_set.types().size();
+
+    EXPECT_THAT(ext_set.EncodeType(*expected_type), ResultWith(Eq(anchor)));
+    auto buf = SubstraitFromJSON(
+        "Type", "{\"user_defined_type_reference\": " + std::to_string(anchor) + "}");
+
+    ASSERT_OK_AND_ASSIGN(auto type, DeserializeType(*buf, ext_set));
+    EXPECT_EQ(*type, *expected_type);
+
+    auto size = ext_set.types().size();
+    ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type, &ext_set));
+    EXPECT_EQ(ext_set.types().size(), size) << "was already added to the set above";
+
+    ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized, ext_set));
+    EXPECT_EQ(*roundtripped, *expected_type);
+  }
+}
+
+TEST(Substrait, NamedStruct) {
+  ExtensionSet ext_set;
+
+  auto buf = SubstraitFromJSON("NamedStruct", R"({
+    "struct": {
+      "types": [
+        {"i64": {}},
+        {"list": {"type": {"string":{}} }},
+        {"struct": {
+          "types": [
+            {"fp32": {"nullability": "NULLABILITY_REQUIRED"}},
+            {"string": {}}
+          ]
+        }},
+        {"list": {"type": {"string":{}} }},
+      ]
+    },
+    "names": ["a", "b", "c", "d", "e", "f"]
+  })");
+  ASSERT_OK_AND_ASSIGN(auto schema, DeserializeSchema(*buf, ext_set));
+  Schema expected_schema({
+      field("a", int64()),
+      field("b", list(utf8())),
+      field("c", struct_({
+                     field("d", float32(), /*nullable=*/false),
+                     field("e", utf8()),
+                 })),
+      field("f", list(utf8())),
+  });
+  EXPECT_EQ(*schema, expected_schema);
+
+  ASSERT_OK_AND_ASSIGN(auto serialized, SerializeSchema(*schema, &ext_set));
+  ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeSchema(*serialized, ext_set));
+  EXPECT_EQ(*roundtripped, expected_schema);
+
+  // too few names
+  buf = SubstraitFromJSON("NamedStruct", R"({
+    "struct": {"types": [{"i32": {}}, {"i32": {}}, {"i32": {}}]},
+    "names": []
+  })");
+  EXPECT_THAT(DeserializeSchema(*buf, ext_set), Raises(StatusCode::Invalid));
+
+  // too many names
+  buf = SubstraitFromJSON("NamedStruct", R"({
+    "struct": {"types": []},
+    "names": ["a", "b", "c"]
+  })");
+  EXPECT_THAT(DeserializeSchema(*buf, ext_set), Raises(StatusCode::Invalid));
+
+  // no schema metadata allowed
+  EXPECT_THAT(SerializeSchema(Schema({}, key_value_metadata({{"ext", "yes"}})), &ext_set),
+              Raises(StatusCode::Invalid));
+
+  // no schema metadata allowed
+  EXPECT_THAT(
+      SerializeSchema(Schema({field("a", int32(), key_value_metadata({{"ext", "yes"}}))}),
+                      &ext_set),
+      Raises(StatusCode::Invalid));
+}
+
+TEST(Substrait, NoEquivalentArrowType) {
+  auto buf = SubstraitFromJSON("Type", R"({"user_defined_type_reference": 99})");
+  ExtensionSet empty;
+  ASSERT_THAT(
+      DeserializeType(*buf, empty),
+      Raises(StatusCode::Invalid, HasSubstr("did not have a corresponding anchor")));
+}
+
+TEST(Substrait, NoEquivalentSubstraitType) {
+  for (auto type : {
+           date32(),
+           timestamp(TimeUnit::SECOND),
+           timestamp(TimeUnit::NANO),
+           timestamp(TimeUnit::MICRO, "New York"),
+           time32(TimeUnit::SECOND),
+           time32(TimeUnit::MILLI),
+           time64(TimeUnit::NANO),
+
+           decimal256(76, 67),
+
+           sparse_union({field("i8", int8()), field("f32", float32())}),
+           dense_union({field("i8", int8()), field("f32", float32())}),
+           dictionary(int32(), utf8()),
+
+           fixed_size_list(float16(), 3),
+
+           duration(TimeUnit::MICRO),
+
+           large_utf8(),
+           large_binary(),
+           large_list(utf8()),
+       }) {
+    ARROW_SCOPED_TRACE(type->ToString());
+    ExtensionSet set;
+    EXPECT_THAT(SerializeType(*type, &set), Raises(StatusCode::NotImplemented));
+  }
+}
+
+TEST(Substrait, SupportedLiterals) {
+  auto ExpectEq = [](util::string_view json, Datum expected_value) {
+    ARROW_SCOPED_TRACE(json);
+
+    auto buf = SubstraitFromJSON("Expression", "{\"literal\":" + json.to_string() + "}");
+    ExtensionSet ext_set;
+    ASSERT_OK_AND_ASSIGN(auto expr, DeserializeExpression(*buf, ext_set));
+
+    ASSERT_TRUE(expr.literal());
+    ASSERT_THAT(*expr.literal(), DataEq(expected_value));
+
+    ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set));
+    EXPECT_EQ(ext_set.function_ids().size(),
+              0);  // shouldn't need extensions for core literals
+
+    ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized, ext_set));
+
+    ASSERT_TRUE(roundtripped.literal());
+    ASSERT_THAT(*roundtripped.literal(), DataEq(expected_value));
+  };
+
+  ExpectEq(R"({"boolean": true})", Datum(true));
+
+  ExpectEq(R"({"i8": 34})", Datum(int8_t(34)));
+  ExpectEq(R"({"i16": 34})", Datum(int16_t(34)));
+  ExpectEq(R"({"i32": 34})", Datum(int32_t(34)));
+  ExpectEq(R"({"i64": "34"})", Datum(int64_t(34)));
+
+  ExpectEq(R"({"fp32": 3.5})", Datum(3.5F));
+  ExpectEq(R"({"fp64": 7.125})", Datum(7.125));
+
+  ExpectEq(R"({"string": "hello world"})", Datum("hello world"));
+
+  ExpectEq(R"({"binary": "enp6"})", BinaryScalar(Buffer::FromString("zzz")));
+
+  ExpectEq(R"({"timestamp": "579"})", TimestampScalar(579, TimeUnit::MICRO));
+
+  constexpr int64_t kDayFiveOfEpoch = 24 * 60 * 60 * 1000 * 5;
+  static_assert(kDayFiveOfEpoch == 432000000, "until c++ gets string interpolation");
+  ExpectEq(R"({"date": "432000000"})", Date64Scalar(kDayFiveOfEpoch));
+
+  ExpectEq(R"({"time": "64"})", Time64Scalar(64, TimeUnit::MICRO));
+
+  ExpectEq(R"({"interval_year_to_month": {"years": 34, "months": 3}})",
+           ExtensionScalar(FixedSizeListScalar(ArrayFromJSON(int32(), "[34, 3]")),
+                           interval_year()));
+
+  ExpectEq(R"({"interval_day_to_second": {"days": 34, "seconds": 3}})",
+           ExtensionScalar(FixedSizeListScalar(ArrayFromJSON(int32(), "[34, 3]")),
+                           interval_day()));
+
+  ExpectEq(R"({"fixed_char": "zzz"})",
+           ExtensionScalar(
+               FixedSizeBinaryScalar(Buffer::FromString("zzz"), fixed_size_binary(3)),
+               fixed_char(3)));
+
+  ExpectEq(R"({"var_char": {"value": "zzz", "length": 1024}})",
+           ExtensionScalar(StringScalar("zzz"), varchar(1024)));
+
+  ExpectEq(R"({"fixed_binary": "enp6"})",
+           FixedSizeBinaryScalar(Buffer::FromString("zzz"), fixed_size_binary(3)));
+
+  ExpectEq(
+      R"({"decimal": {"value": "0gKWSQAAAAAAAAAAAAAAAA==", "precision": 27, "scale": 5}})",
+      Decimal128Scalar(Decimal128("123456789.0"), decimal128(27, 5)));
+
+  ExpectEq(R"({"timestamp_tz": "579"})", TimestampScalar(579, TimeUnit::MICRO, "UTC"));
+
+  // special case for empty lists
+  ExpectEq(R"({"empty_list": {"type": {"i32": {}}}})",
+           ScalarFromJSON(list(int32()), "[]"));
+
+  ExpectEq(R"({"struct": {
+    "fields": [
+      {"i64": "32"},
+      {"list": {"values": [
+        {"string": "hello"},
+        {"string": "world"}
+      ]}}
+    ]
+  }})",
+           ScalarFromJSON(struct_({
+                              field("", int64()),
+                              field("", list(utf8())),
+                          }),
+                          R"([32, ["hello", "world"]])"));
+
+  // check null scalars:
+  for (auto type : {
+           boolean(),
+
+           int8(),
+           int64(),
+
+           timestamp(TimeUnit::MICRO),
+           interval_year(),
+
+           struct_({
+               field("", int64()),
+               field("", list(utf8())),
+           }),
+       }) {
+    ExtensionSet set;
+    ASSERT_OK_AND_ASSIGN(auto buf, SerializeType(*type, &set));
+    ExpectEq("{\"null\": " + SubstraitToJSON("Type", *buf) + "}", MakeNullScalar(type));
+  }
+}
+
+TEST(Substrait, CannotDeserializeLiteral) {
+  ExtensionSet ext_set;
+
+  // Invalid: missing List.element_type
+  EXPECT_THAT(
+      DeserializeExpression(
+          *SubstraitFromJSON("Expression", R"({"literal": {"list": {"values": []}}})"),
+          ext_set),
+      Raises(StatusCode::Invalid));
+
+  // Invalid: required null literal
+  EXPECT_THAT(
+      DeserializeExpression(
+          *SubstraitFromJSON(
+              "Expression",
+              R"({"literal": {"null": {"bool": {"nullability": "NULLABILITY_REQUIRED"}}}})"),
+          ext_set),
+      Raises(StatusCode::Invalid));
+
+  // no equivalent arrow scalar
+  // FIXME no way to specify scalars of user_defined_type_reference
+}
+
+TEST(Substrait, FieldRefRoundTrip) {
+  for (FieldRef ref : {
+           // by name
+           FieldRef("i32"),
+           FieldRef("ts_ns"),
+           FieldRef("struct"),
+
+           // by index
+           FieldRef(0),
+           FieldRef(1),
+           FieldRef(kBoringSchema->num_fields() - 1),
+           FieldRef(kBoringSchema->GetFieldIndex("struct")),
+
+           // nested
+           FieldRef("struct", "i32"),
+           FieldRef("struct", "struct_i32_str", "i32"),
+           FieldRef(kBoringSchema->GetFieldIndex("struct"), 1),
+       }) {
+    ARROW_SCOPED_TRACE(ref.ToString());
+    ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema));
+
+    ExtensionSet ext_set;
+    ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set));
+    EXPECT_EQ(ext_set.function_ids().size(),
+              0);  // shouldn't need extensions for core field references
+    ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized, ext_set));
+    ASSERT_TRUE(roundtripped.field_ref());
+
+    ASSERT_OK_AND_ASSIGN(auto expected, ref.FindOne(*kBoringSchema));
+    ASSERT_OK_AND_ASSIGN(auto actual, roundtripped.field_ref()->FindOne(*kBoringSchema));
+    EXPECT_EQ(actual.indices(), expected.indices());
+  }
+}
+
+TEST(Substrait, RecursiveFieldRef) {
+  FieldRef ref("struct", "str");
+
+  ARROW_SCOPED_TRACE(ref.ToString());
+  ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema));
+  ExtensionSet ext_set;
+  ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set));
+  auto expected = SubstraitFromJSON("Expression", R"({
+    "selection": {
+      "directReference": {
+        "structField": {
+          "field": 12,
+          "child": {
+            "structField": {
+              "field": 1
+            }
+          }
+        }
+      },
+      "rootReference": {}
+    }
+  })");
+  ASSERT_OK(internal::CheckMessagesEquivalent("Expression", *serialized, *expected));
+}
+
+TEST(Substrait, FieldRefsInExpressions) {
+  ASSERT_OK_AND_ASSIGN(auto expr,
+                       compute::call("struct_field",
+                                     {compute::call("if_else",
+                                                    {
+                                                        compute::literal(true),
+                                                        compute::field_ref("struct"),
+                                                        compute::field_ref("struct"),
+                                                    })},
+                                     compute::StructFieldOptions({0}))
+                           .Bind(*kBoringSchema));
+
+  ExtensionSet ext_set;
+  ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set));
+  auto expected = SubstraitFromJSON("Expression", R"({
+    "selection": {
+      "directReference": {
+        "structField": {
+          "field": 0
+        }
+      },
+      "expression": {
+        "if_then": {
+          "ifs": [
+            {
+              "if": {"literal": {"boolean": true}},
+              "then": {"selection": {"directReference": {"structField": {"field": 12}}}}
+            }
+          ],
+          "else": {"selection": {"directReference": {"structField": {"field": 12}}}}
+        }
+      }
+    }
+  })");
+  ASSERT_OK(internal::CheckMessagesEquivalent("Expression", *serialized, *expected));
+}
+
+TEST(Substrait, CallSpecialCaseRoundTrip) {
+  for (compute::Expression expr : {
+           compute::call("if_else",
+                         {
+                             compute::literal(true),
+                             compute::field_ref({"struct", 1}),
+                             compute::field_ref("str"),
+                         }),
+
+           compute::call(
+               "case_when",
+               {
+                   compute::call("make_struct",
+                                 {compute::literal(false), compute::literal(true)},
+                                 compute::MakeStructOptions({"cond1", "cond2"})),
+                   compute::field_ref({"struct", "str"}),
+                   compute::field_ref({"struct", "struct_i32_str", "str"}),
+                   compute::field_ref("str"),
+               }),
+
+           compute::call("list_element",
+                         {
+                             compute::field_ref("list_i32"),
+                             compute::literal(3),
+                         }),
+
+           compute::call("struct_field",
+                         {compute::call("list_element",
+                                        {
+                                            compute::field_ref("list_struct"),
+                                            compute::literal(42),
+                                        })},
+                         arrow::compute::StructFieldOptions({1})),
+
+           compute::call("struct_field",
+                         {compute::call("list_element",
+                                        {
+                                            compute::field_ref("list_struct"),
+                                            compute::literal(42),
+                                        })},
+                         arrow::compute::StructFieldOptions({2, 0})),
+
+           compute::call("struct_field",
+                         {compute::call("if_else",
+                                        {
+                                            compute::literal(true),
+                                            compute::field_ref("struct"),
+                                            compute::field_ref("struct"),
+                                        })},
+                         compute::StructFieldOptions({0})),
+       }) {
+    ARROW_SCOPED_TRACE(expr.ToString());
+    ASSERT_OK_AND_ASSIGN(expr, expr.Bind(*kBoringSchema));
+
+    ExtensionSet ext_set;
+    ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set));
+
+    // These are special cased as core expressions in substrait; shouldn't require any
+    // extensions.
+    EXPECT_EQ(ext_set.function_ids().size(), 0);
+
+    ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized, ext_set));
+    ASSERT_OK_AND_ASSIGN(roundtripped, roundtripped.Bind(*kBoringSchema));
+    EXPECT_EQ(UseBoringRefs(roundtripped), UseBoringRefs(expr));
+  }
+}
+
+TEST(Substrait, CallExtensionFunction) {
+  for (compute::Expression expr : {
+           compute::call("add", {compute::literal(0), compute::literal(1)}),
+       }) {
+    ARROW_SCOPED_TRACE(expr.ToString());
+    ASSERT_OK_AND_ASSIGN(expr, expr.Bind(*kBoringSchema));
+
+    ExtensionSet ext_set;
+    ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set));
+
+    // These require an extension, so we should have a single-element ext_set.
+    EXPECT_EQ(ext_set.function_ids().size(), 1);
+
+    ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized, ext_set));
+    ASSERT_OK_AND_ASSIGN(roundtripped, roundtripped.Bind(*kBoringSchema));
+    EXPECT_EQ(UseBoringRefs(roundtripped), UseBoringRefs(expr));
+  }
+}
+
+TEST(Substrait, ReadRel) {
+  auto buf = SubstraitFromJSON("Rel", R"({
+    "read": {
+      "base_schema": {
+        "struct": {
+          "types": [ {"i64": {}}, {"bool": {}} ]
+        },
+        "names": ["i", "b"]
+      },
+      "filter": {
+        "selection": {
+          "directReference": {
+            "structField": {
+              "field": 1
+            }
+          }
+        }
+      },
+      "local_files": {
+        "items": [
+          {
+            "uri_file": "file:///tmp/dat1.parquet",
+            "format": "FILE_FORMAT_PARQUET"
+          },
+          {
+            "uri_file": "file:///tmp/dat2.parquet",
+            "format": "FILE_FORMAT_PARQUET"
+          }
+        ]
+      }
+    }
+  })");
+  ExtensionSet ext_set;
+  ASSERT_OK_AND_ASSIGN(auto rel, DeserializeRelation(*buf, ext_set));
+
+  // converting a ReadRel produces a scan Declaration
+  ASSERT_EQ(rel.factory_name, "scan");
+  const auto& scan_node_options =
+      checked_cast<const dataset::ScanNodeOptions&>(*rel.options);
+
+  // filter on the boolean field (#1)
+  EXPECT_EQ(scan_node_options.scan_options->filter, compute::field_ref(1));
+  // project all fields
+  EXPECT_EQ(scan_node_options.scan_options->projection,
+            compute::call("make_struct",
+                          {
+                              compute::field_ref(0),
+                              compute::field_ref(1),
+                          },
+                          compute::MakeStructOptions{{"i", "b"}}));
+
+  // dataset is a FileSystemDataset in parquet format with the specified schema
+  ASSERT_EQ(scan_node_options.dataset->type_name(), "filesystem");
+  const auto& dataset =
+      checked_cast<const dataset::FileSystemDataset&>(*scan_node_options.dataset);
+  EXPECT_THAT(dataset.files(), ElementsAre("/tmp/dat1.parquet", "/tmp/dat2.parquet"));
+  EXPECT_EQ(dataset.format()->type_name(), "parquet");
+  EXPECT_EQ(*dataset.schema(), Schema({field("i", int64()), field("b", boolean())}));
+}
+
+TEST(Substrait, ExtensionSetFromPlan) {
+  auto buf = SubstraitFromJSON("Plan", R"({
+    "relations": [
+      {"rel": {
+        "read": {
+          "base_schema": {
+            "struct": {
+              "types": [ {"i64": {}}, {"bool": {}} ]
+            },
+            "names": ["i", "b"]
+          },
+          "local_files": { "items": [] }
+        }
+      }}
+    ],
+    "extension_uris": [
+      {
+        "extension_uri_anchor": 7,
+        "uri": "https://github.com/apache/arrow/blob/master/format/substrait/extension_types.yaml"
+      }
+    ],
+    "extensions": [
+      {"extension_type": {
+        "extension_uri_reference": 7,
+        "type_anchor": 42,
+        "name": "null"
+      }},
+      {"extension_type_variation": {
+        "extension_uri_reference": 7,
+        "type_variation_anchor": 23,
+        "name": "u8"
+      }},
+      {"extension_function": {
+        "extension_uri_reference": 7,
+        "function_anchor": 42,
+        "name": "add"
+      }}
+    ]
+  })");
+
+  ExtensionSet ext_set;
+  ASSERT_OK_AND_ASSIGN(
+      auto sink_decls,
+      DeserializePlan(
+          *buf, [] { return std::shared_ptr<compute::SinkNodeConsumer>{nullptr}; },
+          &ext_set));
+
+  EXPECT_EQ(ext_set.uris()[7], kArrowExtTypesUri);
+
+  ASSERT_NE(ext_set.types()[42], nullptr);
+  EXPECT_EQ(ext_set.type_ids()[42].uri, kArrowExtTypesUri);
+  EXPECT_EQ(ext_set.type_ids()[42].name, "null");
+  EXPECT_EQ(*ext_set.types()[42], NullType());
+  EXPECT_FALSE(ext_set.type_is_variation(42));
+
+  ASSERT_NE(ext_set.types()[23], nullptr);
+  EXPECT_EQ(ext_set.type_ids()[23].uri, kArrowExtTypesUri);
+  EXPECT_EQ(ext_set.type_ids()[23].name, "u8");
+  EXPECT_EQ(*ext_set.types()[23], UInt8Type());
+  EXPECT_TRUE(ext_set.type_is_variation(23));
+
+  EXPECT_EQ(ext_set.function_ids()[42].uri, kArrowExtTypesUri);
+  EXPECT_EQ(ext_set.function_ids()[42].name, "add");
+  EXPECT_EQ(ext_set.function_names()[42], "add");
+}
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc
new file mode 100644
index 000000000000..0b516436140f
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/type_internal.cc
@@ -0,0 +1,498 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/engine/substrait/type_internal.h"
+
+#include <string>
+#include <vector>
+
+#include "arrow/engine/substrait/extension_types.h"
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/type.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/make_unique.h"
+#include "arrow/visit_type_inline.h"
+
+namespace arrow {
+namespace engine {
+
+namespace internal {
+using ::arrow::internal::make_unique;
+}  // namespace internal
+
+namespace {
+
+template <typename TypeMessage>
+Status CheckVariation(const TypeMessage& type) {
+  if (type.type_variation_reference() == 0) return Status::OK();
+  return Status::NotImplemented("Type variations for ", type.DebugString());
+}
+
+template <typename TypeMessage>
+bool IsNullable(const TypeMessage& type) {
+  // FIXME what can we do with NULLABILITY_UNSPECIFIED
+  return type.nullability() != substrait::Type::NULLABILITY_REQUIRED;
+}
+
+template <typename ArrowType, typename TypeMessage, typename... A>
+Result<std::pair<std::shared_ptr<DataType>, bool>> FromProtoImpl(const TypeMessage& type,
+                                                                 A&&... args) {
+  RETURN_NOT_OK(CheckVariation(type));
+
+  return std::make_pair(std::static_pointer_cast<DataType>(
+                            std::make_shared<ArrowType>(std::forward<A>(args)...)),
+                        IsNullable(type));
+}
+
+template <typename TypeMessage, typename... A>
+Result<std::pair<std::shared_ptr<DataType>, bool>> FromProtoImpl(
+    const TypeMessage& type, std::shared_ptr<DataType> type_factory(A...), A&&... args) {
+  RETURN_NOT_OK(CheckVariation(type));
+
+  return std::make_pair(
+      std::static_pointer_cast<DataType>(type_factory(std::forward<A>(args)...)),
+      IsNullable(type));
+}
+
+template <typename Types, typename NextName>
+Result<FieldVector> FieldsFromProto(int size, const Types& types,
+                                    const NextName& next_name,
+                                    const ExtensionSet& ext_set) {
+  FieldVector fields(size);
+  for (int i = 0; i < size; ++i) {
+    std::string name = next_name();
+    std::shared_ptr<DataType> type;
+    bool nullable;
+
+    if (types[i].has_struct_()) {
+      const auto& struct_ = types[i].struct_();
+
+      ARROW_ASSIGN_OR_RAISE(
+          type, FieldsFromProto(struct_.types_size(), struct_.types(), next_name, ext_set)
+                    .Map(arrow::struct_));
+
+      nullable = IsNullable(struct_);
+    } else {
+      ARROW_ASSIGN_OR_RAISE(std::tie(type, nullable), FromProto(types[i], ext_set));
+    }
+
+    fields[i] = field(std::move(name), std::move(type), nullable);
+  }
+  return fields;
+}
+
+}  // namespace
+
+Result<std::pair<std::shared_ptr<DataType>, bool>> FromProto(
+    const substrait::Type& type, const ExtensionSet& ext_set) {
+  switch (type.kind_case()) {
+    case substrait::Type::kBool:
+      return FromProtoImpl<BooleanType>(type.bool_());
+
+    case substrait::Type::kI8:
+      return FromProtoImpl<Int8Type>(type.i8());
+    case substrait::Type::kI16:
+      return FromProtoImpl<Int16Type>(type.i16());
+    case substrait::Type::kI32:
+      return FromProtoImpl<Int32Type>(type.i32());
+    case substrait::Type::kI64:
+      return FromProtoImpl<Int64Type>(type.i64());
+
+    case substrait::Type::kFp32:
+      return FromProtoImpl<FloatType>(type.fp32());
+    case substrait::Type::kFp64:
+      return FromProtoImpl<DoubleType>(type.fp64());
+
+    case substrait::Type::kString:
+      return FromProtoImpl<StringType>(type.string());
+    case substrait::Type::kBinary:
+      return FromProtoImpl<BinaryType>(type.binary());
+
+    case substrait::Type::kTimestamp:
+      return FromProtoImpl<TimestampType>(type.timestamp(), TimeUnit::MICRO);
+    case substrait::Type::kTimestampTz:
+      return FromProtoImpl<TimestampType>(type.timestamp_tz(), TimeUnit::MICRO,
+                                          TimestampTzTimezoneString());
+    case substrait::Type::kDate:
+      return FromProtoImpl<Date64Type>(type.date());
+
+    case substrait::Type::kTime:
+      return FromProtoImpl<Time64Type>(type.time(), TimeUnit::MICRO);
+
+    case substrait::Type::kIntervalYear:
+      return FromProtoImpl(type.interval_year(), interval_year);
+
+    case substrait::Type::kIntervalDay:
+      return FromProtoImpl(type.interval_day(), interval_day);
+
+    case substrait::Type::kUuid:
+      return FromProtoImpl(type.uuid(), uuid);
+
+    case substrait::Type::kFixedChar:
+      return FromProtoImpl(type.fixed_char(), fixed_char, type.fixed_char().length());
+
+    case substrait::Type::kVarchar:
+      return FromProtoImpl(type.varchar(), varchar, type.varchar().length());
+
+    case substrait::Type::kFixedBinary:
+      return FromProtoImpl<FixedSizeBinaryType>(type.fixed_binary(),
+                                                type.fixed_binary().length());
+
+    case substrait::Type::kDecimal: {
+      const auto& decimal = type.decimal();
+      return FromProtoImpl<Decimal128Type>(decimal, decimal.precision(), decimal.scale());
+    }
+
+    case substrait::Type::kStruct: {
+      const auto& struct_ = type.struct_();
+
+      ARROW_ASSIGN_OR_RAISE(auto fields, FieldsFromProto(
+                                             struct_.types_size(), struct_.types(),
+                                             /*next_name=*/[] { return ""; }, ext_set));
+
+      return FromProtoImpl<StructType>(struct_, std::move(fields));
+    }
+
+    case substrait::Type::kList: {
+      const auto& list = type.list();
+
+      if (!list.has_type()) {
+        return Status::Invalid(
+            "While converting to ListType encountered a missing item type in ",
+            list.DebugString());
+      }
+
+      ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(list.type(), ext_set));
+      return FromProtoImpl<ListType>(
+          list, field("item", std::move(type_nullable.first), type_nullable.second));
+    }
+
+    case substrait::Type::kMap: {
+      const auto& map = type.map();
+
+      static const std::array<char const*, 4> kMissing = {"key and value", "value", "key",
+                                                          nullptr};
+      if (auto missing = kMissing[map.has_key() + map.has_value() * 2]) {
+        return Status::Invalid("While converting to MapType encountered missing ",
+                               missing, " type in ", map.DebugString());
+      }
+
+      ARROW_ASSIGN_OR_RAISE(auto key_nullable, FromProto(map.key(), ext_set));
+      ARROW_ASSIGN_OR_RAISE(auto value_nullable, FromProto(map.value(), ext_set));
+
+      if (key_nullable.second) {
+        return Status::Invalid(
+            "While converting to MapType encountered nullable key field in ",
+            map.DebugString());
+      }
+
+      return FromProtoImpl<MapType>(
+          map, std::move(key_nullable.first),
+          field("value", std::move(value_nullable.first), value_nullable.second));
+    }
+
+    case substrait::Type::kUserDefinedTypeReference: {
+      uint32_t anchor = type.user_defined_type_reference();
+      if (anchor >= ext_set.types().size() || ext_set.types()[anchor] == nullptr) {
+        return Status::Invalid(
+            "User defined type reference ", anchor,
+            " did not have a corresponding anchor in the extension set");
+      }
+      return std::make_pair(ext_set.types()[anchor], true);
+    }
+
+    default:
+      break;
+  }
+
+  return Status::NotImplemented("conversion to arrow::DataType from ",
+                                type.DebugString());
+}
+
+namespace {
+
+struct DataTypeToProtoImpl {
+  Status Visit(const NullType& t) { return EncodeUserDefined(t); }
+
+  Status Visit(const BooleanType& t) {
+    return SetWith(&substrait::Type::set_allocated_bool_);
+  }
+
+  Status Visit(const Int8Type& t) { return SetWith(&substrait::Type::set_allocated_i8); }
+  Status Visit(const Int16Type& t) {
+    return SetWith(&substrait::Type::set_allocated_i16);
+  }
+  Status Visit(const Int32Type& t) {
+    return SetWith(&substrait::Type::set_allocated_i32);
+  }
+  Status Visit(const Int64Type& t) {
+    return SetWith(&substrait::Type::set_allocated_i64);
+  }
+
+  Status Visit(const UInt8Type& t) { return EncodeUserDefined(t); }
+  Status Visit(const UInt16Type& t) { return EncodeUserDefined(t); }
+  Status Visit(const UInt32Type& t) { return EncodeUserDefined(t); }
+  Status Visit(const UInt64Type& t) { return EncodeUserDefined(t); }
+
+  Status Visit(const HalfFloatType& t) { return EncodeUserDefined(t); }
+  Status Visit(const FloatType& t) {
+    return SetWith(&substrait::Type::set_allocated_fp32);
+  }
+  Status Visit(const DoubleType& t) {
+    return SetWith(&substrait::Type::set_allocated_fp64);
+  }
+
+  Status Visit(const StringType& t) {
+    return SetWith(&substrait::Type::set_allocated_string);
+  }
+  Status Visit(const BinaryType& t) {
+    return SetWith(&substrait::Type::set_allocated_binary);
+  }
+
+  Status Visit(const FixedSizeBinaryType& t) {
+    SetWithThen(&substrait::Type::set_allocated_fixed_binary)->set_length(t.byte_width());
+    return Status::OK();
+  }
+
+  Status Visit(const Date32Type& t) { return NotImplemented(t); }
+  Status Visit(const Date64Type& t) {
+    return SetWith(&substrait::Type::set_allocated_date);
+  }
+
+  Status Visit(const TimestampType& t) {
+    if (t.unit() != TimeUnit::MICRO) return NotImplemented(t);
+
+    if (t.timezone() == "") {
+      return SetWith(&substrait::Type::set_allocated_timestamp);
+    }
+    if (t.timezone() == TimestampTzTimezoneString()) {
+      return SetWith(&substrait::Type::set_allocated_timestamp_tz);
+    }
+
+    return NotImplemented(t);
+  }
+
+  Status Visit(const Time32Type& t) { return NotImplemented(t); }
+  Status Visit(const Time64Type& t) {
+    if (t.unit() != TimeUnit::MICRO) return NotImplemented(t);
+    return SetWith(&substrait::Type::set_allocated_time);
+  }
+
+  Status Visit(const MonthIntervalType& t) { return EncodeUserDefined(t); }
+  Status Visit(const DayTimeIntervalType& t) { return EncodeUserDefined(t); }
+
+  Status Visit(const Decimal128Type& t) {
+    auto dec = SetWithThen(&substrait::Type::set_allocated_decimal);
+    dec->set_precision(t.precision());
+    dec->set_scale(t.scale());
+    return Status::OK();
+  }
+  Status Visit(const Decimal256Type& t) { return NotImplemented(t); }
+
+  Status Visit(const ListType& t) {
+    // FIXME assert default field name; custom ones won't roundtrip
+    ARROW_ASSIGN_OR_RAISE(
+        auto type, ToProto(*t.value_type(), t.value_field()->nullable(), ext_set_));
+    SetWithThen(&substrait::Type::set_allocated_list)->set_allocated_type(type.release());
+    return Status::OK();
+  }
+
+  Status Visit(const StructType& t) {
+    auto types = SetWithThen(&substrait::Type::set_allocated_struct_)->mutable_types();
+
+    types->Reserve(t.num_fields());
+
+    for (const auto& field : t.fields()) {
+      if (field->metadata() != nullptr) {
+        return Status::Invalid("substrait::Type::Struct does not support field metadata");
+      }
+      ARROW_ASSIGN_OR_RAISE(auto type,
+                            ToProto(*field->type(), field->nullable(), ext_set_));
+      types->AddAllocated(type.release());
+    }
+    return Status::OK();
+  }
+
+  Status Visit(const SparseUnionType& t) { return NotImplemented(t); }
+  Status Visit(const DenseUnionType& t) { return NotImplemented(t); }
+  Status Visit(const DictionaryType& t) { return NotImplemented(t); }
+
+  Status Visit(const MapType& t) {
+    // FIXME assert default field names; custom ones won't roundtrip
+    auto map = SetWithThen(&substrait::Type::set_allocated_map);
+
+    ARROW_ASSIGN_OR_RAISE(auto key, ToProto(*t.key_type(), /*nullable=*/false, ext_set_));
+    map->set_allocated_key(key.release());
+
+    ARROW_ASSIGN_OR_RAISE(
+        auto value, ToProto(*t.value_type(), t.value_field()->nullable(), ext_set_));
+    map->set_allocated_value(value.release());
+
+    return Status::OK();
+  }
+
+  Status Visit(const ExtensionType& t) {
+    if (UnwrapUuid(t)) {
+      return SetWith(&substrait::Type::set_allocated_uuid);
+    }
+
+    if (auto length = UnwrapFixedChar(t)) {
+      SetWithThen(&substrait::Type::set_allocated_fixed_char)->set_length(*length);
+      return Status::OK();
+    }
+
+    if (auto length = UnwrapVarChar(t)) {
+      SetWithThen(&substrait::Type::set_allocated_varchar)->set_length(*length);
+      return Status::OK();
+    }
+
+    if (UnwrapIntervalYear(t)) {
+      return SetWith(&substrait::Type::set_allocated_interval_year);
+    }
+
+    if (UnwrapIntervalDay(t)) {
+      return SetWith(&substrait::Type::set_allocated_interval_day);
+    }
+
+    return NotImplemented(t);
+  }
+
+  Status Visit(const FixedSizeListType& t) { return NotImplemented(t); }
+  Status Visit(const DurationType& t) { return NotImplemented(t); }
+  Status Visit(const LargeStringType& t) { return NotImplemented(t); }
+  Status Visit(const LargeBinaryType& t) { return NotImplemented(t); }
+  Status Visit(const LargeListType& t) { return NotImplemented(t); }
+  Status Visit(const MonthDayNanoIntervalType& t) { return EncodeUserDefined(t); }
+
+  template <typename Sub>
+  Sub* SetWithThen(void (substrait::Type::*set_allocated_sub)(Sub*)) {
+    auto sub = internal::make_unique<Sub>();
+    sub->set_nullability(nullable_ ? substrait::Type::NULLABILITY_NULLABLE
+                                   : substrait::Type::NULLABILITY_REQUIRED);
+
+    auto out = sub.get();
+    (type_->*set_allocated_sub)(sub.release());
+    return out;
+  }
+
+  template <typename Sub>
+  Status SetWith(void (substrait::Type::*set_allocated_sub)(Sub*)) {
+    return SetWithThen(set_allocated_sub), Status::OK();
+  }
+
+  template <typename T>
+  Status EncodeUserDefined(const T& t) {
+    ARROW_ASSIGN_OR_RAISE(auto anchor, ext_set_->EncodeType(t));
+    type_->set_user_defined_type_reference(anchor);
+    return Status::OK();
+  }
+
+  Status NotImplemented(const DataType& t) {
+    return Status::NotImplemented("conversion to substrait::Type from ", t.ToString());
+  }
+
+  Status operator()(const DataType& type) { return VisitTypeInline(type, this); }
+
+  substrait::Type* type_;
+  bool nullable_;
+  ExtensionSet* ext_set_;
+};
+}  // namespace
+
+Result<std::unique_ptr<substrait::Type>> ToProto(const DataType& type, bool nullable,
+                                                 ExtensionSet* ext_set) {
+  auto out = internal::make_unique<substrait::Type>();
+  RETURN_NOT_OK((DataTypeToProtoImpl{out.get(), nullable, ext_set})(type));
+  return std::move(out);
+}
+
+Result<std::shared_ptr<Schema>> FromProto(const substrait::NamedStruct& named_struct,
+                                          const ExtensionSet& ext_set) {
+  if (!named_struct.has_struct_()) {
+    return Status::Invalid("While converting ", named_struct.DebugString(),
+                           " no anonymous struct type was provided to which to names "
+                           "could be attached.");
+  }
+  const auto& struct_ = named_struct.struct_();
+  RETURN_NOT_OK(CheckVariation(struct_));
+
+  int requested_names_count = 0;
+  ARROW_ASSIGN_OR_RAISE(auto fields, FieldsFromProto(
+                                         struct_.types_size(), struct_.types(),
+                                         /*next_name=*/
+                                         [&] {
+                                           int i = requested_names_count++;
+                                           return i < named_struct.names_size()
+                                                      ? named_struct.names().Get(i)
+                                                      : "";
+                                         },
+                                         ext_set));
+
+  if (requested_names_count != named_struct.names_size()) {
+    return Status::Invalid("While converting ", named_struct.DebugString(), " received ",
+                           named_struct.names_size(), " names but ",
+                           requested_names_count, " struct fields");
+  }
+
+  return schema(std::move(fields));
+}
+
+namespace {
+void ToProtoGetDepthFirstNames(const FieldVector& fields,
+                               google::protobuf::RepeatedPtrField<std::string>* names) {
+  for (const auto& field : fields) {
+    *names->Add() = field->name();
+
+    if (field->type()->id() == Type::STRUCT) {
+      ToProtoGetDepthFirstNames(field->type()->fields(), names);
+    }
+  }
+}
+}  // namespace
+
+Result<std::unique_ptr<substrait::NamedStruct>> ToProto(const Schema& schema,
+                                                        ExtensionSet* ext_set) {
+  if (schema.metadata()) {
+    return Status::Invalid("substrait::NamedStruct does not support schema metadata");
+  }
+
+  auto named_struct = internal::make_unique<substrait::NamedStruct>();
+
+  auto names = named_struct->mutable_names();
+  names->Reserve(schema.num_fields());
+  ToProtoGetDepthFirstNames(schema.fields(), names);
+
+  auto struct_ = internal::make_unique<substrait::Type::Struct>();
+  auto types = struct_->mutable_types();
+  types->Reserve(schema.num_fields());
+
+  for (const auto& field : schema.fields()) {
+    if (field->metadata() != nullptr) {
+      return Status::Invalid("substrait::NamedStruct does not support field metadata");
+    }
+
+    ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*field->type(), field->nullable(), ext_set));
+    types->AddAllocated(type.release());
+  }
+
+  named_struct->set_allocated_struct_(struct_.release());
+  return std::move(named_struct);
+}
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/type_internal.h b/cpp/src/arrow/engine/substrait/type_internal.h
new file mode 100644
index 000000000000..380c07024d0c
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/type_internal.h
@@ -0,0 +1,51 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// This API is EXPERIMENTAL.
+
+#pragma once
+
+#include <utility>
+
+#include "arrow/engine/substrait/extension_set.h"
+#include "arrow/engine/visibility.h"
+#include "arrow/type_fwd.h"
+
+#include "generated/substrait/type.pb.h"  // IWYU pragma: export
+
+namespace arrow {
+namespace engine {
+
+ARROW_ENGINE_EXPORT
+Result<std::pair<std::shared_ptr<DataType>, bool>> FromProto(const substrait::Type&,
+                                                             const ExtensionSet&);
+
+ARROW_ENGINE_EXPORT
+Result<std::unique_ptr<substrait::Type>> ToProto(const DataType&, bool nullable,
+                                                 ExtensionSet*);
+
+ARROW_ENGINE_EXPORT
+Result<std::shared_ptr<Schema>> FromProto(const substrait::NamedStruct&,
+                                          const ExtensionSet&);
+
+ARROW_ENGINE_EXPORT
+Result<std::unique_ptr<substrait::NamedStruct>> ToProto(const Schema&, ExtensionSet*);
+
+inline std::string TimestampTzTimezoneString() { return "UTC"; }
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/visibility.h b/cpp/src/arrow/engine/visibility.h
new file mode 100644
index 000000000000..5b1651f78ab9
--- /dev/null
+++ b/cpp/src/arrow/engine/visibility.h
@@ -0,0 +1,50 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// This API is EXPERIMENTAL.
+
+#pragma once
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4251)
+#else
+#pragma GCC diagnostic ignored "-Wattributes"
+#endif
+
+#ifdef ARROW_ENGINE_STATIC
+#define ARROW_ENGINE_EXPORT
+#elif defined(ARROW_ENGINE_EXPORTING)
+#define ARROW_ENGINE_EXPORT __declspec(dllexport)
+#else
+#define ARROW_ENGINE_EXPORT __declspec(dllimport)
+#endif
+
+#define ARROW_ENGINE_NO_EXPORT
+#else  // Not Windows
+#ifndef ARROW_ENGINE_EXPORT
+#define ARROW_ENGINE_EXPORT __attribute__((visibility("default")))
+#endif
+#ifndef ARROW_ENGINE_NO_EXPORT
+#define ARROW_ENGINE_NO_EXPORT __attribute__((visibility("hidden")))
+#endif
+#endif  // Non-Windows
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
diff --git a/cpp/src/arrow/flight/CMakeLists.txt b/cpp/src/arrow/flight/CMakeLists.txt
index 2cf8c9913e57..bcebe3e73aac 100644
--- a/cpp/src/arrow/flight/CMakeLists.txt
+++ b/cpp/src/arrow/flight/CMakeLists.txt
@@ -53,7 +53,7 @@ endif()
 # TODO(wesm): Protobuf shared vs static linking
 
 set(FLIGHT_PROTO_PATH "${ARROW_SOURCE_DIR}/../format")
-set(FLIGHT_PROTO ${ARROW_SOURCE_DIR}/../format/Flight.proto)
+set(FLIGHT_PROTO "${ARROW_SOURCE_DIR}/../format/Flight.proto")
 
 set(FLIGHT_GENERATED_PROTO_FILES
     "${CMAKE_CURRENT_BINARY_DIR}/Flight.pb.cc" "${CMAKE_CURRENT_BINARY_DIR}/Flight.pb.h"
@@ -152,9 +152,9 @@ endif()
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_BACKUP}")
 
 # Note, we do not compile the generated Protobuf sources directly, instead
-# compiling then via protocol_internal.cc which contains some gRPC template
+# compiling them via protocol_internal.cc which contains some gRPC template
 # overrides to enable Flight-specific optimizations. See comments in
-# protobuf-internal.cc
+# protocol_internal.cc
 set(ARROW_FLIGHT_SRCS
     client.cc
     client_cookie_middleware.cc
diff --git a/cpp/src/arrow/scalar.h b/cpp/src/arrow/scalar.h
index 9df3e3c74e3f..e5a398b7014d 100644
--- a/cpp/src/arrow/scalar.h
+++ b/cpp/src/arrow/scalar.h
@@ -345,8 +345,8 @@ struct ARROW_EXPORT TimestampScalar : public TemporalScalar<TimestampType> {
   using TemporalScalar<TimestampType>::TemporalScalar;
 
   TimestampScalar(typename TemporalScalar<TimestampType>::ValueType value,
-                  TimeUnit::type unit)
-      : TimestampScalar(std::move(value), timestamp(unit)) {}
+                  TimeUnit::type unit, std::string tz = "")
+      : TimestampScalar(std::move(value), timestamp(unit, std::move(tz))) {}
 };
 
 template <typename T>
@@ -533,6 +533,11 @@ struct ARROW_EXPORT ExtensionScalar : public Scalar {
   ExtensionScalar(std::shared_ptr<Scalar> storage, std::shared_ptr<DataType> type)
       : Scalar(std::move(type), true), value(std::move(storage)) {}
 
+  template <typename Storage,
+            typename = enable_if_t<std::is_base_of<Scalar, Storage>::value>>
+  ExtensionScalar(Storage&& storage, std::shared_ptr<DataType> type)
+      : ExtensionScalar(std::make_shared<Storage>(std::move(storage)), std::move(type)) {}
+
   std::shared_ptr<Scalar> value;
 };
 
diff --git a/cpp/src/arrow/status_test.cc b/cpp/src/arrow/status_test.cc
index 10a79d9b9903..a8e1d1ca9a84 100644
--- a/cpp/src/arrow/status_test.cc
+++ b/cpp/src/arrow/status_test.cc
@@ -179,20 +179,19 @@ TEST(StatusTest, MatcherExplanations) {
   {
     testing::StringMatchResultListener listener;
     EXPECT_TRUE(matcher.MatchAndExplain(Status::Invalid("XXX"), &listener));
-    EXPECT_THAT(listener.str(), testing::StrEq("whose value \"Invalid: XXX\" matches"));
+    EXPECT_THAT(listener.str(), testing::StrEq("whose error matches"));
   }
 
   {
     testing::StringMatchResultListener listener;
     EXPECT_FALSE(matcher.MatchAndExplain(Status::OK(), &listener));
-    EXPECT_THAT(listener.str(), testing::StrEq("whose value \"OK\" doesn't match"));
+    EXPECT_THAT(listener.str(), testing::StrEq("whose non-error doesn't match"));
   }
 
   {
     testing::StringMatchResultListener listener;
     EXPECT_FALSE(matcher.MatchAndExplain(Status::TypeError("XXX"), &listener));
-    EXPECT_THAT(listener.str(),
-                testing::StrEq("whose value \"Type error: XXX\" doesn't match"));
+    EXPECT_THAT(listener.str(), testing::StrEq("whose error doesn't match"));
   }
 }
 
diff --git a/cpp/src/arrow/testing/matchers.h b/cpp/src/arrow/testing/matchers.h
index ddfe60f17405..be88c3f93b40 100644
--- a/cpp/src/arrow/testing/matchers.h
+++ b/cpp/src/arrow/testing/matchers.h
@@ -24,9 +24,11 @@
 #include "arrow/datum.h"
 #include "arrow/result.h"
 #include "arrow/status.h"
+#include "arrow/stl_iterator.h"
 #include "arrow/testing/future_util.h"
 #include "arrow/testing/gtest_util.h"
 #include "arrow/util/future.h"
+#include "arrow/util/unreachable.h"
 
 namespace arrow {
 
@@ -196,8 +198,14 @@ class ErrorMatcher {
                   message_matcher_->MatchAndExplain(status.message(), &value_listener);
         }
 
-        *listener << "whose value " << testing::PrintToString(status.ToString())
-                  << (match ? " matches" : " doesn't match");
+        if (match) {
+          *listener << "whose error matches";
+        } else if (status.ok()) {
+          *listener << "whose non-error doesn't match";
+        } else {
+          *listener << "whose error doesn't match";
+        }
+
         testing::internal::PrintIfNotEmpty(value_listener.str(), listener->stream());
         return match;
       }
@@ -228,8 +236,7 @@ class OkMatcher {
         const Status& status = internal::GenericToStatus(maybe_value);
 
         const bool match = status.ok();
-        *listener << "whose value " << testing::PrintToString(status.ToString())
-                  << (match ? " matches" : " doesn't match");
+        *listener << "whose " << (match ? "non-error matches" : "error doesn't match");
         return match;
       }
     };
@@ -268,6 +275,9 @@ ErrorMatcher Raises(StatusCode code, const MessageMatcher& message_matcher) {
 
 class DataEqMatcher {
  public:
+  // TODO(bkietz) support EqualOptions, ApproxEquals, etc
+  // Probably it's better to use something like config-through-key_value_metadata
+  // as with the random generators to decouple this from EqualOptions etc.
   explicit DataEqMatcher(Datum expected) : expected_(std::move(expected)) {}
 
   template <typename Data>
@@ -295,17 +305,34 @@ class DataEqMatcher {
           return false;
         }
 
-        if (*boxed.type() != *expected_.type()) {
-          *listener << "whose DataType " << boxed.type()->ToString() << " doesn't match "
-                    << expected_.type()->ToString();
-          return false;
+        if (const auto& boxed_type = boxed.type()) {
+          if (*boxed_type != *expected_.type()) {
+            *listener << "whose DataType " << boxed_type->ToString() << " doesn't match "
+                      << expected_.type()->ToString();
+            return false;
+          }
+        } else if (const auto& boxed_schema = boxed.schema()) {
+          if (*boxed_schema != *expected_.schema()) {
+            *listener << "whose Schema " << boxed_schema->ToString() << " doesn't match "
+                      << expected_.schema()->ToString();
+            return false;
+          }
+        } else {
+          Unreachable();
         }
 
-        const bool match = boxed == expected_;
-        *listener << "whose value ";
-        PrintTo(boxed, listener->stream());
-        *listener << (match ? " matches" : " doesn't match");
-        return match;
+        if (boxed == expected_) {
+          *listener << "whose value matches";
+          return true;
+        }
+
+        if (listener->IsInterested() && boxed.kind() == Datum::ARRAY) {
+          *listener << "whose value differs from the expected value by "
+                    << boxed.make_array()->Diff(*expected_.make_array());
+        } else {
+          *listener << "whose value doesn't match";
+        }
+        return false;
       }
 
       Datum expected_;
@@ -318,9 +345,66 @@ class DataEqMatcher {
   Datum expected_;
 };
 
+/// Constructs a datum against which arguments are matched
 template <typename Data>
 DataEqMatcher DataEq(Data&& dat) {
   return DataEqMatcher(Datum(std::forward<Data>(dat)));
 }
 
+/// Constructs an array with ArrayFromJSON against which arguments are matched
+inline DataEqMatcher DataEqArray(const std::shared_ptr<DataType>& type,
+                                 util::string_view json) {
+  return DataEq(ArrayFromJSON(type, json));
+}
+
+/// Constructs an array from a vector of optionals against which arguments are matched
+template <typename T, typename ArrayType = typename TypeTraits<T>::ArrayType,
+          typename BuilderType = typename TypeTraits<T>::BuilderType,
+          typename ValueType =
+              typename ::arrow::stl::detail::DefaultValueAccessor<ArrayType>::ValueType>
+DataEqMatcher DataEqArray(T type, const std::vector<util::optional<ValueType>>& values) {
+  // FIXME(bkietz) broken until DataType is move constructible
+  BuilderType builder(std::make_shared<T>(std::move(type)), default_memory_pool());
+  DCHECK_OK(builder.Reserve(static_cast<int64_t>(values.size())));
+
+  // pseudo constexpr:
+  static const bool need_safe_append = !is_fixed_width(T::type_id);
+
+  for (auto value : values) {
+    if (value) {
+      if (need_safe_append) {
+        builder.UnsafeAppend(*value);
+      } else {
+        DCHECK_OK(builder.Append(*value));
+      }
+    } else {
+      builder.UnsafeAppendNull();
+    }
+  }
+
+  return DataEq(builder.Finish().ValueOrDie());
+}
+
+/// Constructs a scalar with ScalarFromJSON against which arguments are matched
+inline DataEqMatcher DataEqScalar(const std::shared_ptr<DataType>& type,
+                                  util::string_view json) {
+  return DataEq(ScalarFromJSON(type, json));
+}
+
+/// Constructs a scalar against which arguments are matched
+template <typename T, typename ScalarType = typename TypeTraits<T>::ScalarType,
+          typename ValueType = typename ScalarType::ValueType>
+DataEqMatcher DataEqScalar(T type, util::optional<ValueType> value) {
+  ScalarType expected(std::make_shared<T>(std::move(type)));
+
+  if (value) {
+    expected.is_valid = true;
+    expected.value = std::move(*value);
+  }
+
+  return DataEq(std::move(expected));
+}
+
+// HasType, HasSchema matchers
+
 }  // namespace arrow
diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index 2a382662497a..5842d4bc92f2 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -1544,7 +1544,7 @@ Result<std::shared_ptr<Schema>> Schema::AddField(
 Result<std::shared_ptr<Schema>> Schema::SetField(
     int i, const std::shared_ptr<Field>& field) const {
   if (i < 0 || i > this->num_fields()) {
-    return Status::Invalid("Invalid column index to set field.");
+    return Status::Invalid("Invalid column index to add field.");
   }
 
   return std::make_shared<Schema>(
diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h
index 4c439841ba20..7381d94b43e5 100644
--- a/cpp/src/arrow/type.h
+++ b/cpp/src/arrow/type.h
@@ -82,8 +82,8 @@ class ARROW_EXPORT Fingerprintable {
   virtual std::string ComputeFingerprint() const = 0;
   virtual std::string ComputeMetadataFingerprint() const = 0;
 
-  mutable std::atomic<std::string*> fingerprint_;
-  mutable std::atomic<std::string*> metadata_fingerprint_;
+  mutable std::atomic<std::string*> fingerprint_{NULLPTR};
+  mutable std::atomic<std::string*> metadata_fingerprint_{NULLPTR};
 };
 
 }  // namespace detail
@@ -817,7 +817,7 @@ class ARROW_EXPORT Decimal256Type : public DecimalType {
 class ARROW_EXPORT BaseListType : public NestedType {
  public:
   using NestedType::NestedType;
-  std::shared_ptr<Field> value_field() const { return children_[0]; }
+  const std::shared_ptr<Field>& value_field() const { return children_[0]; }
 
   std::shared_ptr<DataType> value_type() const { return children_[0]->type(); }
 };
diff --git a/cpp/src/arrow/util/hashing.h b/cpp/src/arrow/util/hashing.h
index 328d7e7ca214..d2c0178b008a 100644
--- a/cpp/src/arrow/util/hashing.h
+++ b/cpp/src/arrow/util/hashing.h
@@ -882,5 +882,14 @@ static inline Status ComputeNullBitmap(MemoryPool* pool, const MemoTableType& me
   return Status::OK();
 }
 
+struct StringViewHash {
+  // std::hash compatible hasher for use with std::unordered_*
+  // (the std::hash specialization provided by nonstd constructs std::string
+  // temporaries then invokes std::hash<std::string> against those)
+  hash_t operator()(const util::string_view& value) const {
+    return ComputeStringHash<0>(value.data(), static_cast<int64_t>(value.size()));
+  }
+};
+
 }  // namespace internal
 }  // namespace arrow
diff --git a/cpp/src/generated/substrait/capabilities.pb.cc b/cpp/src/generated/substrait/capabilities.pb.cc
new file mode 100644
index 000000000000..a87949956df3
--- /dev/null
+++ b/cpp/src/generated/substrait/capabilities.pb.cc
@@ -0,0 +1,701 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/capabilities.proto
+
+#include "substrait/capabilities.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace substrait {
+constexpr Capabilities_SimpleExtension::Capabilities_SimpleExtension(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : function_keys_()
+  , type_keys_()
+  , type_variation_keys_()
+  , uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct Capabilities_SimpleExtensionDefaultTypeInternal {
+  constexpr Capabilities_SimpleExtensionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Capabilities_SimpleExtensionDefaultTypeInternal() {}
+  union {
+    Capabilities_SimpleExtension _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Capabilities_SimpleExtensionDefaultTypeInternal _Capabilities_SimpleExtension_default_instance_;
+constexpr Capabilities::Capabilities(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : substrait_versions_()
+  , advanced_extension_type_urls_()
+  , simple_extensions_(){}
+struct CapabilitiesDefaultTypeInternal {
+  constexpr CapabilitiesDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~CapabilitiesDefaultTypeInternal() {}
+  union {
+    Capabilities _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CapabilitiesDefaultTypeInternal _Capabilities_default_instance_;
+}  // namespace substrait
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fcapabilities_2eproto[2];
+static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fcapabilities_2eproto = nullptr;
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fcapabilities_2eproto = nullptr;
+
+const uint32_t TableStruct_substrait_2fcapabilities_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, uri_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, function_keys_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, type_keys_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, type_variation_keys_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, substrait_versions_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, advanced_extension_type_urls_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, simple_extensions_),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, -1, sizeof(::substrait::Capabilities_SimpleExtension)},
+  { 10, -1, -1, sizeof(::substrait::Capabilities)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Capabilities_SimpleExtension_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Capabilities_default_instance_),
+};
+
+const char descriptor_table_protodef_substrait_2fcapabilities_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\034substrait/capabilities.proto\022\tsubstrai"
+  "t\"\373\001\n\014Capabilities\022\032\n\022substrait_versions"
+  "\030\001 \003(\t\022$\n\034advanced_extension_type_urls\030\002"
+  " \003(\t\022B\n\021simple_extensions\030\003 \003(\0132\'.substr"
+  "ait.Capabilities.SimpleExtension\032e\n\017Simp"
+  "leExtension\022\013\n\003uri\030\001 \001(\t\022\025\n\rfunction_key"
+  "s\030\002 \003(\t\022\021\n\ttype_keys\030\003 \003(\t\022\033\n\023type_varia"
+  "tion_keys\030\004 \003(\tB+\n\022io.substrait.protoP\001\252"
+  "\002\022Substrait.Protobufb\006proto3"
+  ;
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fcapabilities_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fcapabilities_2eproto = {
+  false, false, 348, descriptor_table_protodef_substrait_2fcapabilities_2eproto, "substrait/capabilities.proto", 
+  &descriptor_table_substrait_2fcapabilities_2eproto_once, nullptr, 0, 2,
+  schemas, file_default_instances, TableStruct_substrait_2fcapabilities_2eproto::offsets,
+  file_level_metadata_substrait_2fcapabilities_2eproto, file_level_enum_descriptors_substrait_2fcapabilities_2eproto, file_level_service_descriptors_substrait_2fcapabilities_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fcapabilities_2eproto_getter() {
+  return &descriptor_table_substrait_2fcapabilities_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fcapabilities_2eproto(&descriptor_table_substrait_2fcapabilities_2eproto);
+namespace substrait {
+
+// ===================================================================
+
+class Capabilities_SimpleExtension::_Internal {
+ public:
+};
+
+Capabilities_SimpleExtension::Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  function_keys_(arena),
+  type_keys_(arena),
+  type_variation_keys_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Capabilities.SimpleExtension)
+}
+Capabilities_SimpleExtension::Capabilities_SimpleExtension(const Capabilities_SimpleExtension& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      function_keys_(from.function_keys_),
+      type_keys_(from.type_keys_),
+      type_variation_keys_(from.type_variation_keys_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_uri().empty()) {
+    uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), 
+      GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Capabilities.SimpleExtension)
+}
+
+inline void Capabilities_SimpleExtension::SharedCtor() {
+uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Capabilities_SimpleExtension::~Capabilities_SimpleExtension() {
+  // @@protoc_insertion_point(destructor:substrait.Capabilities.SimpleExtension)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Capabilities_SimpleExtension::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Capabilities_SimpleExtension::ArenaDtor(void* object) {
+  Capabilities_SimpleExtension* _this = reinterpret_cast< Capabilities_SimpleExtension* >(object);
+  (void)_this;
+}
+void Capabilities_SimpleExtension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Capabilities_SimpleExtension::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Capabilities_SimpleExtension::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Capabilities.SimpleExtension)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  function_keys_.Clear();
+  type_keys_.Clear();
+  type_variation_keys_.Clear();
+  uri_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Capabilities_SimpleExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string uri = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_uri();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.uri"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string function_keys = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_function_keys();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.function_keys"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string type_keys = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_type_keys();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.type_keys"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string type_variation_keys = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_type_variation_keys();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.type_variation_keys"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Capabilities_SimpleExtension::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Capabilities.SimpleExtension)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string uri = 1;
+  if (!this->_internal_uri().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_uri().data(), static_cast<int>(this->_internal_uri().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Capabilities.SimpleExtension.uri");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_uri(), target);
+  }
+
+  // repeated string function_keys = 2;
+  for (int i = 0, n = this->_internal_function_keys_size(); i < n; i++) {
+    const auto& s = this->_internal_function_keys(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Capabilities.SimpleExtension.function_keys");
+    target = stream->WriteString(2, s, target);
+  }
+
+  // repeated string type_keys = 3;
+  for (int i = 0, n = this->_internal_type_keys_size(); i < n; i++) {
+    const auto& s = this->_internal_type_keys(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Capabilities.SimpleExtension.type_keys");
+    target = stream->WriteString(3, s, target);
+  }
+
+  // repeated string type_variation_keys = 4;
+  for (int i = 0, n = this->_internal_type_variation_keys_size(); i < n; i++) {
+    const auto& s = this->_internal_type_variation_keys(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Capabilities.SimpleExtension.type_variation_keys");
+    target = stream->WriteString(4, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Capabilities.SimpleExtension)
+  return target;
+}
+
+size_t Capabilities_SimpleExtension::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Capabilities.SimpleExtension)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string function_keys = 2;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(function_keys_.size());
+  for (int i = 0, n = function_keys_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      function_keys_.Get(i));
+  }
+
+  // repeated string type_keys = 3;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(type_keys_.size());
+  for (int i = 0, n = type_keys_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      type_keys_.Get(i));
+  }
+
+  // repeated string type_variation_keys = 4;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(type_variation_keys_.size());
+  for (int i = 0, n = type_variation_keys_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      type_variation_keys_.Get(i));
+  }
+
+  // string uri = 1;
+  if (!this->_internal_uri().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_uri());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Capabilities_SimpleExtension::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Capabilities_SimpleExtension::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Capabilities_SimpleExtension::GetClassData() const { return &_class_data_; }
+
+void Capabilities_SimpleExtension::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Capabilities_SimpleExtension *>(to)->MergeFrom(
+      static_cast<const Capabilities_SimpleExtension &>(from));
+}
+
+
+void Capabilities_SimpleExtension::MergeFrom(const Capabilities_SimpleExtension& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Capabilities.SimpleExtension)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  function_keys_.MergeFrom(from.function_keys_);
+  type_keys_.MergeFrom(from.type_keys_);
+  type_variation_keys_.MergeFrom(from.type_variation_keys_);
+  if (!from._internal_uri().empty()) {
+    _internal_set_uri(from._internal_uri());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Capabilities_SimpleExtension::CopyFrom(const Capabilities_SimpleExtension& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Capabilities.SimpleExtension)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Capabilities_SimpleExtension::IsInitialized() const {
+  return true;
+}
+
+void Capabilities_SimpleExtension::InternalSwap(Capabilities_SimpleExtension* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  function_keys_.InternalSwap(&other->function_keys_);
+  type_keys_.InternalSwap(&other->type_keys_);
+  type_variation_keys_.InternalSwap(&other->type_variation_keys_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &uri_, lhs_arena,
+      &other->uri_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Capabilities_SimpleExtension::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fcapabilities_2eproto_getter, &descriptor_table_substrait_2fcapabilities_2eproto_once,
+      file_level_metadata_substrait_2fcapabilities_2eproto[0]);
+}
+
+// ===================================================================
+
+class Capabilities::_Internal {
+ public:
+};
+
+Capabilities::Capabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  substrait_versions_(arena),
+  advanced_extension_type_urls_(arena),
+  simple_extensions_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Capabilities)
+}
+Capabilities::Capabilities(const Capabilities& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      substrait_versions_(from.substrait_versions_),
+      advanced_extension_type_urls_(from.advanced_extension_type_urls_),
+      simple_extensions_(from.simple_extensions_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.Capabilities)
+}
+
+inline void Capabilities::SharedCtor() {
+}
+
+Capabilities::~Capabilities() {
+  // @@protoc_insertion_point(destructor:substrait.Capabilities)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Capabilities::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Capabilities::ArenaDtor(void* object) {
+  Capabilities* _this = reinterpret_cast< Capabilities* >(object);
+  (void)_this;
+}
+void Capabilities::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Capabilities::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Capabilities::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Capabilities)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  substrait_versions_.Clear();
+  advanced_extension_type_urls_.Clear();
+  simple_extensions_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Capabilities::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated string substrait_versions = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_substrait_versions();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.substrait_versions"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string advanced_extension_type_urls = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_advanced_extension_type_urls();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.advanced_extension_type_urls"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_simple_extensions(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Capabilities::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Capabilities)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string substrait_versions = 1;
+  for (int i = 0, n = this->_internal_substrait_versions_size(); i < n; i++) {
+    const auto& s = this->_internal_substrait_versions(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Capabilities.substrait_versions");
+    target = stream->WriteString(1, s, target);
+  }
+
+  // repeated string advanced_extension_type_urls = 2;
+  for (int i = 0, n = this->_internal_advanced_extension_type_urls_size(); i < n; i++) {
+    const auto& s = this->_internal_advanced_extension_type_urls(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Capabilities.advanced_extension_type_urls");
+    target = stream->WriteString(2, s, target);
+  }
+
+  // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_simple_extensions_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, this->_internal_simple_extensions(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Capabilities)
+  return target;
+}
+
+size_t Capabilities::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Capabilities)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string substrait_versions = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(substrait_versions_.size());
+  for (int i = 0, n = substrait_versions_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      substrait_versions_.Get(i));
+  }
+
+  // repeated string advanced_extension_type_urls = 2;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(advanced_extension_type_urls_.size());
+  for (int i = 0, n = advanced_extension_type_urls_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      advanced_extension_type_urls_.Get(i));
+  }
+
+  // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3;
+  total_size += 1UL * this->_internal_simple_extensions_size();
+  for (const auto& msg : this->simple_extensions_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Capabilities::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Capabilities::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Capabilities::GetClassData() const { return &_class_data_; }
+
+void Capabilities::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Capabilities *>(to)->MergeFrom(
+      static_cast<const Capabilities &>(from));
+}
+
+
+void Capabilities::MergeFrom(const Capabilities& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Capabilities)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  substrait_versions_.MergeFrom(from.substrait_versions_);
+  advanced_extension_type_urls_.MergeFrom(from.advanced_extension_type_urls_);
+  simple_extensions_.MergeFrom(from.simple_extensions_);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Capabilities::CopyFrom(const Capabilities& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Capabilities)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Capabilities::IsInitialized() const {
+  return true;
+}
+
+void Capabilities::InternalSwap(Capabilities* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  substrait_versions_.InternalSwap(&other->substrait_versions_);
+  advanced_extension_type_urls_.InternalSwap(&other->advanced_extension_type_urls_);
+  simple_extensions_.InternalSwap(&other->simple_extensions_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Capabilities::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fcapabilities_2eproto_getter, &descriptor_table_substrait_2fcapabilities_2eproto_once,
+      file_level_metadata_substrait_2fcapabilities_2eproto[1]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::substrait::Capabilities_SimpleExtension* Arena::CreateMaybeMessage< ::substrait::Capabilities_SimpleExtension >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Capabilities_SimpleExtension >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Capabilities* Arena::CreateMaybeMessage< ::substrait::Capabilities >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Capabilities >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/cpp/src/generated/substrait/capabilities.pb.h b/cpp/src/generated/substrait/capabilities.pb.h
new file mode 100644
index 000000000000..1ac303703ffe
--- /dev/null
+++ b/cpp/src/generated/substrait/capabilities.pb.h
@@ -0,0 +1,1002 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/capabilities.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fcapabilities_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fcapabilities_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3019000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3019003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_substrait_2fcapabilities_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_substrait_2fcapabilities_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fcapabilities_2eproto;
+namespace substrait {
+class Capabilities;
+struct CapabilitiesDefaultTypeInternal;
+extern CapabilitiesDefaultTypeInternal _Capabilities_default_instance_;
+class Capabilities_SimpleExtension;
+struct Capabilities_SimpleExtensionDefaultTypeInternal;
+extern Capabilities_SimpleExtensionDefaultTypeInternal _Capabilities_SimpleExtension_default_instance_;
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> ::substrait::Capabilities* Arena::CreateMaybeMessage<::substrait::Capabilities>(Arena*);
+template<> ::substrait::Capabilities_SimpleExtension* Arena::CreateMaybeMessage<::substrait::Capabilities_SimpleExtension>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace substrait {
+
+// ===================================================================
+
+class Capabilities_SimpleExtension final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Capabilities.SimpleExtension) */ {
+ public:
+  inline Capabilities_SimpleExtension() : Capabilities_SimpleExtension(nullptr) {}
+  ~Capabilities_SimpleExtension() override;
+  explicit constexpr Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Capabilities_SimpleExtension(const Capabilities_SimpleExtension& from);
+  Capabilities_SimpleExtension(Capabilities_SimpleExtension&& from) noexcept
+    : Capabilities_SimpleExtension() {
+    *this = ::std::move(from);
+  }
+
+  inline Capabilities_SimpleExtension& operator=(const Capabilities_SimpleExtension& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Capabilities_SimpleExtension& operator=(Capabilities_SimpleExtension&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Capabilities_SimpleExtension& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Capabilities_SimpleExtension* internal_default_instance() {
+    return reinterpret_cast<const Capabilities_SimpleExtension*>(
+               &_Capabilities_SimpleExtension_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Capabilities_SimpleExtension& a, Capabilities_SimpleExtension& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Capabilities_SimpleExtension* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Capabilities_SimpleExtension* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Capabilities_SimpleExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Capabilities_SimpleExtension>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Capabilities_SimpleExtension& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Capabilities_SimpleExtension& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Capabilities_SimpleExtension* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Capabilities.SimpleExtension";
+  }
+  protected:
+  explicit Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFunctionKeysFieldNumber = 2,
+    kTypeKeysFieldNumber = 3,
+    kTypeVariationKeysFieldNumber = 4,
+    kUriFieldNumber = 1,
+  };
+  // repeated string function_keys = 2;
+  int function_keys_size() const;
+  private:
+  int _internal_function_keys_size() const;
+  public:
+  void clear_function_keys();
+  const std::string& function_keys(int index) const;
+  std::string* mutable_function_keys(int index);
+  void set_function_keys(int index, const std::string& value);
+  void set_function_keys(int index, std::string&& value);
+  void set_function_keys(int index, const char* value);
+  void set_function_keys(int index, const char* value, size_t size);
+  std::string* add_function_keys();
+  void add_function_keys(const std::string& value);
+  void add_function_keys(std::string&& value);
+  void add_function_keys(const char* value);
+  void add_function_keys(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& function_keys() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_function_keys();
+  private:
+  const std::string& _internal_function_keys(int index) const;
+  std::string* _internal_add_function_keys();
+  public:
+
+  // repeated string type_keys = 3;
+  int type_keys_size() const;
+  private:
+  int _internal_type_keys_size() const;
+  public:
+  void clear_type_keys();
+  const std::string& type_keys(int index) const;
+  std::string* mutable_type_keys(int index);
+  void set_type_keys(int index, const std::string& value);
+  void set_type_keys(int index, std::string&& value);
+  void set_type_keys(int index, const char* value);
+  void set_type_keys(int index, const char* value, size_t size);
+  std::string* add_type_keys();
+  void add_type_keys(const std::string& value);
+  void add_type_keys(std::string&& value);
+  void add_type_keys(const char* value);
+  void add_type_keys(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& type_keys() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_type_keys();
+  private:
+  const std::string& _internal_type_keys(int index) const;
+  std::string* _internal_add_type_keys();
+  public:
+
+  // repeated string type_variation_keys = 4;
+  int type_variation_keys_size() const;
+  private:
+  int _internal_type_variation_keys_size() const;
+  public:
+  void clear_type_variation_keys();
+  const std::string& type_variation_keys(int index) const;
+  std::string* mutable_type_variation_keys(int index);
+  void set_type_variation_keys(int index, const std::string& value);
+  void set_type_variation_keys(int index, std::string&& value);
+  void set_type_variation_keys(int index, const char* value);
+  void set_type_variation_keys(int index, const char* value, size_t size);
+  std::string* add_type_variation_keys();
+  void add_type_variation_keys(const std::string& value);
+  void add_type_variation_keys(std::string&& value);
+  void add_type_variation_keys(const char* value);
+  void add_type_variation_keys(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& type_variation_keys() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_type_variation_keys();
+  private:
+  const std::string& _internal_type_variation_keys(int index) const;
+  std::string* _internal_add_type_variation_keys();
+  public:
+
+  // string uri = 1;
+  void clear_uri();
+  const std::string& uri() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_uri(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_uri();
+  PROTOBUF_NODISCARD std::string* release_uri();
+  void set_allocated_uri(std::string* uri);
+  private:
+  const std::string& _internal_uri() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri(const std::string& value);
+  std::string* _internal_mutable_uri();
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Capabilities.SimpleExtension)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> function_keys_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> type_keys_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> type_variation_keys_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fcapabilities_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Capabilities final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Capabilities) */ {
+ public:
+  inline Capabilities() : Capabilities(nullptr) {}
+  ~Capabilities() override;
+  explicit constexpr Capabilities(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Capabilities(const Capabilities& from);
+  Capabilities(Capabilities&& from) noexcept
+    : Capabilities() {
+    *this = ::std::move(from);
+  }
+
+  inline Capabilities& operator=(const Capabilities& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Capabilities& operator=(Capabilities&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Capabilities& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Capabilities* internal_default_instance() {
+    return reinterpret_cast<const Capabilities*>(
+               &_Capabilities_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(Capabilities& a, Capabilities& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Capabilities* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Capabilities* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Capabilities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Capabilities>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Capabilities& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Capabilities& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Capabilities* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Capabilities";
+  }
+  protected:
+  explicit Capabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Capabilities_SimpleExtension SimpleExtension;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSubstraitVersionsFieldNumber = 1,
+    kAdvancedExtensionTypeUrlsFieldNumber = 2,
+    kSimpleExtensionsFieldNumber = 3,
+  };
+  // repeated string substrait_versions = 1;
+  int substrait_versions_size() const;
+  private:
+  int _internal_substrait_versions_size() const;
+  public:
+  void clear_substrait_versions();
+  const std::string& substrait_versions(int index) const;
+  std::string* mutable_substrait_versions(int index);
+  void set_substrait_versions(int index, const std::string& value);
+  void set_substrait_versions(int index, std::string&& value);
+  void set_substrait_versions(int index, const char* value);
+  void set_substrait_versions(int index, const char* value, size_t size);
+  std::string* add_substrait_versions();
+  void add_substrait_versions(const std::string& value);
+  void add_substrait_versions(std::string&& value);
+  void add_substrait_versions(const char* value);
+  void add_substrait_versions(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& substrait_versions() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_substrait_versions();
+  private:
+  const std::string& _internal_substrait_versions(int index) const;
+  std::string* _internal_add_substrait_versions();
+  public:
+
+  // repeated string advanced_extension_type_urls = 2;
+  int advanced_extension_type_urls_size() const;
+  private:
+  int _internal_advanced_extension_type_urls_size() const;
+  public:
+  void clear_advanced_extension_type_urls();
+  const std::string& advanced_extension_type_urls(int index) const;
+  std::string* mutable_advanced_extension_type_urls(int index);
+  void set_advanced_extension_type_urls(int index, const std::string& value);
+  void set_advanced_extension_type_urls(int index, std::string&& value);
+  void set_advanced_extension_type_urls(int index, const char* value);
+  void set_advanced_extension_type_urls(int index, const char* value, size_t size);
+  std::string* add_advanced_extension_type_urls();
+  void add_advanced_extension_type_urls(const std::string& value);
+  void add_advanced_extension_type_urls(std::string&& value);
+  void add_advanced_extension_type_urls(const char* value);
+  void add_advanced_extension_type_urls(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& advanced_extension_type_urls() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_advanced_extension_type_urls();
+  private:
+  const std::string& _internal_advanced_extension_type_urls(int index) const;
+  std::string* _internal_add_advanced_extension_type_urls();
+  public:
+
+  // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3;
+  int simple_extensions_size() const;
+  private:
+  int _internal_simple_extensions_size() const;
+  public:
+  void clear_simple_extensions();
+  ::substrait::Capabilities_SimpleExtension* mutable_simple_extensions(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >*
+      mutable_simple_extensions();
+  private:
+  const ::substrait::Capabilities_SimpleExtension& _internal_simple_extensions(int index) const;
+  ::substrait::Capabilities_SimpleExtension* _internal_add_simple_extensions();
+  public:
+  const ::substrait::Capabilities_SimpleExtension& simple_extensions(int index) const;
+  ::substrait::Capabilities_SimpleExtension* add_simple_extensions();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >&
+      simple_extensions() const;
+
+  // @@protoc_insertion_point(class_scope:substrait.Capabilities)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> substrait_versions_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> advanced_extension_type_urls_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension > simple_extensions_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fcapabilities_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Capabilities_SimpleExtension
+
+// string uri = 1;
+inline void Capabilities_SimpleExtension::clear_uri() {
+  uri_.ClearToEmpty();
+}
+inline const std::string& Capabilities_SimpleExtension::uri() const {
+  // @@protoc_insertion_point(field_get:substrait.Capabilities.SimpleExtension.uri)
+  return _internal_uri();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Capabilities_SimpleExtension::set_uri(ArgT0&& arg0, ArgT... args) {
+ 
+ uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.uri)
+}
+inline std::string* Capabilities_SimpleExtension::mutable_uri() {
+  std::string* _s = _internal_mutable_uri();
+  // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.uri)
+  return _s;
+}
+inline const std::string& Capabilities_SimpleExtension::_internal_uri() const {
+  return uri_.Get();
+}
+inline void Capabilities_SimpleExtension::_internal_set_uri(const std::string& value) {
+  
+  uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Capabilities_SimpleExtension::_internal_mutable_uri() {
+  
+  return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Capabilities_SimpleExtension::release_uri() {
+  // @@protoc_insertion_point(field_release:substrait.Capabilities.SimpleExtension.uri)
+  return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void Capabilities_SimpleExtension::set_allocated_uri(std::string* uri) {
+  if (uri != nullptr) {
+    
+  } else {
+    
+  }
+  uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (uri_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.Capabilities.SimpleExtension.uri)
+}
+
+// repeated string function_keys = 2;
+inline int Capabilities_SimpleExtension::_internal_function_keys_size() const {
+  return function_keys_.size();
+}
+inline int Capabilities_SimpleExtension::function_keys_size() const {
+  return _internal_function_keys_size();
+}
+inline void Capabilities_SimpleExtension::clear_function_keys() {
+  function_keys_.Clear();
+}
+inline std::string* Capabilities_SimpleExtension::add_function_keys() {
+  std::string* _s = _internal_add_function_keys();
+  // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.SimpleExtension.function_keys)
+  return _s;
+}
+inline const std::string& Capabilities_SimpleExtension::_internal_function_keys(int index) const {
+  return function_keys_.Get(index);
+}
+inline const std::string& Capabilities_SimpleExtension::function_keys(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Capabilities.SimpleExtension.function_keys)
+  return _internal_function_keys(index);
+}
+inline std::string* Capabilities_SimpleExtension::mutable_function_keys(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.function_keys)
+  return function_keys_.Mutable(index);
+}
+inline void Capabilities_SimpleExtension::set_function_keys(int index, const std::string& value) {
+  function_keys_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.function_keys)
+}
+inline void Capabilities_SimpleExtension::set_function_keys(int index, std::string&& value) {
+  function_keys_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.function_keys)
+}
+inline void Capabilities_SimpleExtension::set_function_keys(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  function_keys_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.Capabilities.SimpleExtension.function_keys)
+}
+inline void Capabilities_SimpleExtension::set_function_keys(int index, const char* value, size_t size) {
+  function_keys_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.SimpleExtension.function_keys)
+}
+inline std::string* Capabilities_SimpleExtension::_internal_add_function_keys() {
+  return function_keys_.Add();
+}
+inline void Capabilities_SimpleExtension::add_function_keys(const std::string& value) {
+  function_keys_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.function_keys)
+}
+inline void Capabilities_SimpleExtension::add_function_keys(std::string&& value) {
+  function_keys_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.function_keys)
+}
+inline void Capabilities_SimpleExtension::add_function_keys(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  function_keys_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.Capabilities.SimpleExtension.function_keys)
+}
+inline void Capabilities_SimpleExtension::add_function_keys(const char* value, size_t size) {
+  function_keys_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.SimpleExtension.function_keys)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Capabilities_SimpleExtension::function_keys() const {
+  // @@protoc_insertion_point(field_list:substrait.Capabilities.SimpleExtension.function_keys)
+  return function_keys_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Capabilities_SimpleExtension::mutable_function_keys() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.SimpleExtension.function_keys)
+  return &function_keys_;
+}
+
+// repeated string type_keys = 3;
+inline int Capabilities_SimpleExtension::_internal_type_keys_size() const {
+  return type_keys_.size();
+}
+inline int Capabilities_SimpleExtension::type_keys_size() const {
+  return _internal_type_keys_size();
+}
+inline void Capabilities_SimpleExtension::clear_type_keys() {
+  type_keys_.Clear();
+}
+inline std::string* Capabilities_SimpleExtension::add_type_keys() {
+  std::string* _s = _internal_add_type_keys();
+  // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.SimpleExtension.type_keys)
+  return _s;
+}
+inline const std::string& Capabilities_SimpleExtension::_internal_type_keys(int index) const {
+  return type_keys_.Get(index);
+}
+inline const std::string& Capabilities_SimpleExtension::type_keys(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Capabilities.SimpleExtension.type_keys)
+  return _internal_type_keys(index);
+}
+inline std::string* Capabilities_SimpleExtension::mutable_type_keys(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.type_keys)
+  return type_keys_.Mutable(index);
+}
+inline void Capabilities_SimpleExtension::set_type_keys(int index, const std::string& value) {
+  type_keys_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_keys)
+}
+inline void Capabilities_SimpleExtension::set_type_keys(int index, std::string&& value) {
+  type_keys_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_keys)
+}
+inline void Capabilities_SimpleExtension::set_type_keys(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  type_keys_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.Capabilities.SimpleExtension.type_keys)
+}
+inline void Capabilities_SimpleExtension::set_type_keys(int index, const char* value, size_t size) {
+  type_keys_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.SimpleExtension.type_keys)
+}
+inline std::string* Capabilities_SimpleExtension::_internal_add_type_keys() {
+  return type_keys_.Add();
+}
+inline void Capabilities_SimpleExtension::add_type_keys(const std::string& value) {
+  type_keys_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.type_keys)
+}
+inline void Capabilities_SimpleExtension::add_type_keys(std::string&& value) {
+  type_keys_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.type_keys)
+}
+inline void Capabilities_SimpleExtension::add_type_keys(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  type_keys_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.Capabilities.SimpleExtension.type_keys)
+}
+inline void Capabilities_SimpleExtension::add_type_keys(const char* value, size_t size) {
+  type_keys_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.SimpleExtension.type_keys)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Capabilities_SimpleExtension::type_keys() const {
+  // @@protoc_insertion_point(field_list:substrait.Capabilities.SimpleExtension.type_keys)
+  return type_keys_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Capabilities_SimpleExtension::mutable_type_keys() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.SimpleExtension.type_keys)
+  return &type_keys_;
+}
+
+// repeated string type_variation_keys = 4;
+inline int Capabilities_SimpleExtension::_internal_type_variation_keys_size() const {
+  return type_variation_keys_.size();
+}
+inline int Capabilities_SimpleExtension::type_variation_keys_size() const {
+  return _internal_type_variation_keys_size();
+}
+inline void Capabilities_SimpleExtension::clear_type_variation_keys() {
+  type_variation_keys_.Clear();
+}
+inline std::string* Capabilities_SimpleExtension::add_type_variation_keys() {
+  std::string* _s = _internal_add_type_variation_keys();
+  // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.SimpleExtension.type_variation_keys)
+  return _s;
+}
+inline const std::string& Capabilities_SimpleExtension::_internal_type_variation_keys(int index) const {
+  return type_variation_keys_.Get(index);
+}
+inline const std::string& Capabilities_SimpleExtension::type_variation_keys(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Capabilities.SimpleExtension.type_variation_keys)
+  return _internal_type_variation_keys(index);
+}
+inline std::string* Capabilities_SimpleExtension::mutable_type_variation_keys(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.type_variation_keys)
+  return type_variation_keys_.Mutable(index);
+}
+inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const std::string& value) {
+  type_variation_keys_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_variation_keys)
+}
+inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, std::string&& value) {
+  type_variation_keys_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_variation_keys)
+}
+inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  type_variation_keys_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.Capabilities.SimpleExtension.type_variation_keys)
+}
+inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const char* value, size_t size) {
+  type_variation_keys_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.SimpleExtension.type_variation_keys)
+}
+inline std::string* Capabilities_SimpleExtension::_internal_add_type_variation_keys() {
+  return type_variation_keys_.Add();
+}
+inline void Capabilities_SimpleExtension::add_type_variation_keys(const std::string& value) {
+  type_variation_keys_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.type_variation_keys)
+}
+inline void Capabilities_SimpleExtension::add_type_variation_keys(std::string&& value) {
+  type_variation_keys_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.type_variation_keys)
+}
+inline void Capabilities_SimpleExtension::add_type_variation_keys(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  type_variation_keys_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.Capabilities.SimpleExtension.type_variation_keys)
+}
+inline void Capabilities_SimpleExtension::add_type_variation_keys(const char* value, size_t size) {
+  type_variation_keys_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.SimpleExtension.type_variation_keys)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Capabilities_SimpleExtension::type_variation_keys() const {
+  // @@protoc_insertion_point(field_list:substrait.Capabilities.SimpleExtension.type_variation_keys)
+  return type_variation_keys_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Capabilities_SimpleExtension::mutable_type_variation_keys() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.SimpleExtension.type_variation_keys)
+  return &type_variation_keys_;
+}
+
+// -------------------------------------------------------------------
+
+// Capabilities
+
+// repeated string substrait_versions = 1;
+inline int Capabilities::_internal_substrait_versions_size() const {
+  return substrait_versions_.size();
+}
+inline int Capabilities::substrait_versions_size() const {
+  return _internal_substrait_versions_size();
+}
+inline void Capabilities::clear_substrait_versions() {
+  substrait_versions_.Clear();
+}
+inline std::string* Capabilities::add_substrait_versions() {
+  std::string* _s = _internal_add_substrait_versions();
+  // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.substrait_versions)
+  return _s;
+}
+inline const std::string& Capabilities::_internal_substrait_versions(int index) const {
+  return substrait_versions_.Get(index);
+}
+inline const std::string& Capabilities::substrait_versions(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Capabilities.substrait_versions)
+  return _internal_substrait_versions(index);
+}
+inline std::string* Capabilities::mutable_substrait_versions(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Capabilities.substrait_versions)
+  return substrait_versions_.Mutable(index);
+}
+inline void Capabilities::set_substrait_versions(int index, const std::string& value) {
+  substrait_versions_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.Capabilities.substrait_versions)
+}
+inline void Capabilities::set_substrait_versions(int index, std::string&& value) {
+  substrait_versions_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.Capabilities.substrait_versions)
+}
+inline void Capabilities::set_substrait_versions(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  substrait_versions_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.Capabilities.substrait_versions)
+}
+inline void Capabilities::set_substrait_versions(int index, const char* value, size_t size) {
+  substrait_versions_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.substrait_versions)
+}
+inline std::string* Capabilities::_internal_add_substrait_versions() {
+  return substrait_versions_.Add();
+}
+inline void Capabilities::add_substrait_versions(const std::string& value) {
+  substrait_versions_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.Capabilities.substrait_versions)
+}
+inline void Capabilities::add_substrait_versions(std::string&& value) {
+  substrait_versions_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.Capabilities.substrait_versions)
+}
+inline void Capabilities::add_substrait_versions(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  substrait_versions_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.Capabilities.substrait_versions)
+}
+inline void Capabilities::add_substrait_versions(const char* value, size_t size) {
+  substrait_versions_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.substrait_versions)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Capabilities::substrait_versions() const {
+  // @@protoc_insertion_point(field_list:substrait.Capabilities.substrait_versions)
+  return substrait_versions_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Capabilities::mutable_substrait_versions() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.substrait_versions)
+  return &substrait_versions_;
+}
+
+// repeated string advanced_extension_type_urls = 2;
+inline int Capabilities::_internal_advanced_extension_type_urls_size() const {
+  return advanced_extension_type_urls_.size();
+}
+inline int Capabilities::advanced_extension_type_urls_size() const {
+  return _internal_advanced_extension_type_urls_size();
+}
+inline void Capabilities::clear_advanced_extension_type_urls() {
+  advanced_extension_type_urls_.Clear();
+}
+inline std::string* Capabilities::add_advanced_extension_type_urls() {
+  std::string* _s = _internal_add_advanced_extension_type_urls();
+  // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.advanced_extension_type_urls)
+  return _s;
+}
+inline const std::string& Capabilities::_internal_advanced_extension_type_urls(int index) const {
+  return advanced_extension_type_urls_.Get(index);
+}
+inline const std::string& Capabilities::advanced_extension_type_urls(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Capabilities.advanced_extension_type_urls)
+  return _internal_advanced_extension_type_urls(index);
+}
+inline std::string* Capabilities::mutable_advanced_extension_type_urls(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Capabilities.advanced_extension_type_urls)
+  return advanced_extension_type_urls_.Mutable(index);
+}
+inline void Capabilities::set_advanced_extension_type_urls(int index, const std::string& value) {
+  advanced_extension_type_urls_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.Capabilities.advanced_extension_type_urls)
+}
+inline void Capabilities::set_advanced_extension_type_urls(int index, std::string&& value) {
+  advanced_extension_type_urls_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.Capabilities.advanced_extension_type_urls)
+}
+inline void Capabilities::set_advanced_extension_type_urls(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  advanced_extension_type_urls_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.Capabilities.advanced_extension_type_urls)
+}
+inline void Capabilities::set_advanced_extension_type_urls(int index, const char* value, size_t size) {
+  advanced_extension_type_urls_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.advanced_extension_type_urls)
+}
+inline std::string* Capabilities::_internal_add_advanced_extension_type_urls() {
+  return advanced_extension_type_urls_.Add();
+}
+inline void Capabilities::add_advanced_extension_type_urls(const std::string& value) {
+  advanced_extension_type_urls_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.Capabilities.advanced_extension_type_urls)
+}
+inline void Capabilities::add_advanced_extension_type_urls(std::string&& value) {
+  advanced_extension_type_urls_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.Capabilities.advanced_extension_type_urls)
+}
+inline void Capabilities::add_advanced_extension_type_urls(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  advanced_extension_type_urls_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.Capabilities.advanced_extension_type_urls)
+}
+inline void Capabilities::add_advanced_extension_type_urls(const char* value, size_t size) {
+  advanced_extension_type_urls_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.advanced_extension_type_urls)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Capabilities::advanced_extension_type_urls() const {
+  // @@protoc_insertion_point(field_list:substrait.Capabilities.advanced_extension_type_urls)
+  return advanced_extension_type_urls_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Capabilities::mutable_advanced_extension_type_urls() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.advanced_extension_type_urls)
+  return &advanced_extension_type_urls_;
+}
+
+// repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3;
+inline int Capabilities::_internal_simple_extensions_size() const {
+  return simple_extensions_.size();
+}
+inline int Capabilities::simple_extensions_size() const {
+  return _internal_simple_extensions_size();
+}
+inline void Capabilities::clear_simple_extensions() {
+  simple_extensions_.Clear();
+}
+inline ::substrait::Capabilities_SimpleExtension* Capabilities::mutable_simple_extensions(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Capabilities.simple_extensions)
+  return simple_extensions_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >*
+Capabilities::mutable_simple_extensions() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.simple_extensions)
+  return &simple_extensions_;
+}
+inline const ::substrait::Capabilities_SimpleExtension& Capabilities::_internal_simple_extensions(int index) const {
+  return simple_extensions_.Get(index);
+}
+inline const ::substrait::Capabilities_SimpleExtension& Capabilities::simple_extensions(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Capabilities.simple_extensions)
+  return _internal_simple_extensions(index);
+}
+inline ::substrait::Capabilities_SimpleExtension* Capabilities::_internal_add_simple_extensions() {
+  return simple_extensions_.Add();
+}
+inline ::substrait::Capabilities_SimpleExtension* Capabilities::add_simple_extensions() {
+  ::substrait::Capabilities_SimpleExtension* _add = _internal_add_simple_extensions();
+  // @@protoc_insertion_point(field_add:substrait.Capabilities.simple_extensions)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >&
+Capabilities::simple_extensions() const {
+  // @@protoc_insertion_point(field_list:substrait.Capabilities.simple_extensions)
+  return simple_extensions_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace substrait
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fcapabilities_2eproto
diff --git a/cpp/src/generated/substrait/expression.pb.cc b/cpp/src/generated/substrait/expression.pb.cc
new file mode 100644
index 000000000000..c58095ef801f
--- /dev/null
+++ b/cpp/src/generated/substrait/expression.pb.cc
@@ -0,0 +1,14785 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/expression.proto
+
+#include "substrait/expression.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace substrait {
+constexpr Expression_Enum_Empty::Expression_Enum_Empty(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
+struct Expression_Enum_EmptyDefaultTypeInternal {
+  constexpr Expression_Enum_EmptyDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_Enum_EmptyDefaultTypeInternal() {}
+  union {
+    Expression_Enum_Empty _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Enum_EmptyDefaultTypeInternal _Expression_Enum_Empty_default_instance_;
+constexpr Expression_Enum::Expression_Enum(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct Expression_EnumDefaultTypeInternal {
+  constexpr Expression_EnumDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_EnumDefaultTypeInternal() {}
+  union {
+    Expression_Enum _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EnumDefaultTypeInternal _Expression_Enum_default_instance_;
+constexpr Expression_Literal_VarChar::Expression_Literal_VarChar(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , length_(0u){}
+struct Expression_Literal_VarCharDefaultTypeInternal {
+  constexpr Expression_Literal_VarCharDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_Literal_VarCharDefaultTypeInternal() {}
+  union {
+    Expression_Literal_VarChar _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_VarCharDefaultTypeInternal _Expression_Literal_VarChar_default_instance_;
+constexpr Expression_Literal_Decimal::Expression_Literal_Decimal(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , precision_(0)
+  , scale_(0){}
+struct Expression_Literal_DecimalDefaultTypeInternal {
+  constexpr Expression_Literal_DecimalDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_Literal_DecimalDefaultTypeInternal() {}
+  union {
+    Expression_Literal_Decimal _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_DecimalDefaultTypeInternal _Expression_Literal_Decimal_default_instance_;
+constexpr Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : key_(nullptr)
+  , value_(nullptr){}
+struct Expression_Literal_Map_KeyValueDefaultTypeInternal {
+  constexpr Expression_Literal_Map_KeyValueDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_Literal_Map_KeyValueDefaultTypeInternal() {}
+  union {
+    Expression_Literal_Map_KeyValue _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_Map_KeyValueDefaultTypeInternal _Expression_Literal_Map_KeyValue_default_instance_;
+constexpr Expression_Literal_Map::Expression_Literal_Map(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : key_values_(){}
+struct Expression_Literal_MapDefaultTypeInternal {
+  constexpr Expression_Literal_MapDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_Literal_MapDefaultTypeInternal() {}
+  union {
+    Expression_Literal_Map _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_MapDefaultTypeInternal _Expression_Literal_Map_default_instance_;
+constexpr Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : years_(0)
+  , months_(0){}
+struct Expression_Literal_IntervalYearToMonthDefaultTypeInternal {
+  constexpr Expression_Literal_IntervalYearToMonthDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_Literal_IntervalYearToMonthDefaultTypeInternal() {}
+  union {
+    Expression_Literal_IntervalYearToMonth _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_IntervalYearToMonthDefaultTypeInternal _Expression_Literal_IntervalYearToMonth_default_instance_;
+constexpr Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : days_(0)
+  , seconds_(0){}
+struct Expression_Literal_IntervalDayToSecondDefaultTypeInternal {
+  constexpr Expression_Literal_IntervalDayToSecondDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_Literal_IntervalDayToSecondDefaultTypeInternal() {}
+  union {
+    Expression_Literal_IntervalDayToSecond _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_IntervalDayToSecondDefaultTypeInternal _Expression_Literal_IntervalDayToSecond_default_instance_;
+constexpr Expression_Literal_Struct::Expression_Literal_Struct(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : fields_(){}
+struct Expression_Literal_StructDefaultTypeInternal {
+  constexpr Expression_Literal_StructDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_Literal_StructDefaultTypeInternal() {}
+  union {
+    Expression_Literal_Struct _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_StructDefaultTypeInternal _Expression_Literal_Struct_default_instance_;
+constexpr Expression_Literal_List::Expression_Literal_List(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : values_(){}
+struct Expression_Literal_ListDefaultTypeInternal {
+  constexpr Expression_Literal_ListDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_Literal_ListDefaultTypeInternal() {}
+  union {
+    Expression_Literal_List _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_ListDefaultTypeInternal _Expression_Literal_List_default_instance_;
+constexpr Expression_Literal::Expression_Literal(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : nullable_(false)
+  , _oneof_case_{}{}
+struct Expression_LiteralDefaultTypeInternal {
+  constexpr Expression_LiteralDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_LiteralDefaultTypeInternal() {}
+  union {
+    Expression_Literal _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_LiteralDefaultTypeInternal _Expression_Literal_default_instance_;
+constexpr Expression_ScalarFunction::Expression_ScalarFunction(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : args_()
+  , output_type_(nullptr)
+  , function_reference_(0u){}
+struct Expression_ScalarFunctionDefaultTypeInternal {
+  constexpr Expression_ScalarFunctionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_ScalarFunctionDefaultTypeInternal() {}
+  union {
+    Expression_ScalarFunction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ScalarFunctionDefaultTypeInternal _Expression_ScalarFunction_default_instance_;
+constexpr Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : offset_(int64_t{0}){}
+struct Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal {
+  constexpr Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal() {}
+  union {
+    Expression_WindowFunction_Bound_Preceding _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal _Expression_WindowFunction_Bound_Preceding_default_instance_;
+constexpr Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : offset_(int64_t{0}){}
+struct Expression_WindowFunction_Bound_FollowingDefaultTypeInternal {
+  constexpr Expression_WindowFunction_Bound_FollowingDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_WindowFunction_Bound_FollowingDefaultTypeInternal() {}
+  union {
+    Expression_WindowFunction_Bound_Following _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_FollowingDefaultTypeInternal _Expression_WindowFunction_Bound_Following_default_instance_;
+constexpr Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
+struct Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal {
+  constexpr Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal() {}
+  union {
+    Expression_WindowFunction_Bound_CurrentRow _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal _Expression_WindowFunction_Bound_CurrentRow_default_instance_;
+constexpr Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
+struct Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal {
+  constexpr Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal() {}
+  union {
+    Expression_WindowFunction_Bound_Unbounded _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal _Expression_WindowFunction_Bound_Unbounded_default_instance_;
+constexpr Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct Expression_WindowFunction_BoundDefaultTypeInternal {
+  constexpr Expression_WindowFunction_BoundDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_WindowFunction_BoundDefaultTypeInternal() {}
+  union {
+    Expression_WindowFunction_Bound _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_BoundDefaultTypeInternal _Expression_WindowFunction_Bound_default_instance_;
+constexpr Expression_WindowFunction::Expression_WindowFunction(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : partitions_()
+  , sorts_()
+  , args_()
+  , upper_bound_(nullptr)
+  , lower_bound_(nullptr)
+  , output_type_(nullptr)
+  , function_reference_(0u)
+  , phase_(0)
+{}
+struct Expression_WindowFunctionDefaultTypeInternal {
+  constexpr Expression_WindowFunctionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_WindowFunctionDefaultTypeInternal() {}
+  union {
+    Expression_WindowFunction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunctionDefaultTypeInternal _Expression_WindowFunction_default_instance_;
+constexpr Expression_IfThen_IfClause::Expression_IfThen_IfClause(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : if__(nullptr)
+  , then_(nullptr){}
+struct Expression_IfThen_IfClauseDefaultTypeInternal {
+  constexpr Expression_IfThen_IfClauseDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_IfThen_IfClauseDefaultTypeInternal() {}
+  union {
+    Expression_IfThen_IfClause _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_IfThen_IfClauseDefaultTypeInternal _Expression_IfThen_IfClause_default_instance_;
+constexpr Expression_IfThen::Expression_IfThen(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : ifs_()
+  , else__(nullptr){}
+struct Expression_IfThenDefaultTypeInternal {
+  constexpr Expression_IfThenDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_IfThenDefaultTypeInternal() {}
+  union {
+    Expression_IfThen _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_IfThenDefaultTypeInternal _Expression_IfThen_default_instance_;
+constexpr Expression_Cast::Expression_Cast(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_(nullptr)
+  , input_(nullptr){}
+struct Expression_CastDefaultTypeInternal {
+  constexpr Expression_CastDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_CastDefaultTypeInternal() {}
+  union {
+    Expression_Cast _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_CastDefaultTypeInternal _Expression_Cast_default_instance_;
+constexpr Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : if__(nullptr)
+  , then_(nullptr){}
+struct Expression_SwitchExpression_IfValueDefaultTypeInternal {
+  constexpr Expression_SwitchExpression_IfValueDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_SwitchExpression_IfValueDefaultTypeInternal() {}
+  union {
+    Expression_SwitchExpression_IfValue _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SwitchExpression_IfValueDefaultTypeInternal _Expression_SwitchExpression_IfValue_default_instance_;
+constexpr Expression_SwitchExpression::Expression_SwitchExpression(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : ifs_()
+  , else__(nullptr){}
+struct Expression_SwitchExpressionDefaultTypeInternal {
+  constexpr Expression_SwitchExpressionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_SwitchExpressionDefaultTypeInternal() {}
+  union {
+    Expression_SwitchExpression _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SwitchExpressionDefaultTypeInternal _Expression_SwitchExpression_default_instance_;
+constexpr Expression_SingularOrList::Expression_SingularOrList(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : options_()
+  , value_(nullptr){}
+struct Expression_SingularOrListDefaultTypeInternal {
+  constexpr Expression_SingularOrListDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_SingularOrListDefaultTypeInternal() {}
+  union {
+    Expression_SingularOrList _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SingularOrListDefaultTypeInternal _Expression_SingularOrList_default_instance_;
+constexpr Expression_MultiOrList_Record::Expression_MultiOrList_Record(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : fields_(){}
+struct Expression_MultiOrList_RecordDefaultTypeInternal {
+  constexpr Expression_MultiOrList_RecordDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MultiOrList_RecordDefaultTypeInternal() {}
+  union {
+    Expression_MultiOrList_Record _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MultiOrList_RecordDefaultTypeInternal _Expression_MultiOrList_Record_default_instance_;
+constexpr Expression_MultiOrList::Expression_MultiOrList(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : value_()
+  , options_(){}
+struct Expression_MultiOrListDefaultTypeInternal {
+  constexpr Expression_MultiOrListDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MultiOrListDefaultTypeInternal() {}
+  union {
+    Expression_MultiOrList _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MultiOrListDefaultTypeInternal _Expression_MultiOrList_default_instance_;
+constexpr Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : prerequisite_()
+  , function_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal {
+  constexpr Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal() {}
+  union {
+    Expression_EmbeddedFunction_PythonPickleFunction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal _Expression_EmbeddedFunction_PythonPickleFunction_default_instance_;
+constexpr Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : prerequisite_()
+  , script_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal {
+  constexpr Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal() {}
+  union {
+    Expression_EmbeddedFunction_WebAssemblyFunction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal _Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_;
+constexpr Expression_EmbeddedFunction::Expression_EmbeddedFunction(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : arguments_()
+  , output_type_(nullptr)
+  , _oneof_case_{}{}
+struct Expression_EmbeddedFunctionDefaultTypeInternal {
+  constexpr Expression_EmbeddedFunctionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_EmbeddedFunctionDefaultTypeInternal() {}
+  union {
+    Expression_EmbeddedFunction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunctionDefaultTypeInternal _Expression_EmbeddedFunction_default_instance_;
+constexpr Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : map_key_(nullptr)
+  , child_(nullptr){}
+struct Expression_ReferenceSegment_MapKeyDefaultTypeInternal {
+  constexpr Expression_ReferenceSegment_MapKeyDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_ReferenceSegment_MapKeyDefaultTypeInternal() {}
+  union {
+    Expression_ReferenceSegment_MapKey _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegment_MapKeyDefaultTypeInternal _Expression_ReferenceSegment_MapKey_default_instance_;
+constexpr Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : child_(nullptr)
+  , field_(0){}
+struct Expression_ReferenceSegment_StructFieldDefaultTypeInternal {
+  constexpr Expression_ReferenceSegment_StructFieldDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_ReferenceSegment_StructFieldDefaultTypeInternal() {}
+  union {
+    Expression_ReferenceSegment_StructField _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegment_StructFieldDefaultTypeInternal _Expression_ReferenceSegment_StructField_default_instance_;
+constexpr Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : child_(nullptr)
+  , offset_(0){}
+struct Expression_ReferenceSegment_ListElementDefaultTypeInternal {
+  constexpr Expression_ReferenceSegment_ListElementDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_ReferenceSegment_ListElementDefaultTypeInternal() {}
+  union {
+    Expression_ReferenceSegment_ListElement _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegment_ListElementDefaultTypeInternal _Expression_ReferenceSegment_ListElement_default_instance_;
+constexpr Expression_ReferenceSegment::Expression_ReferenceSegment(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct Expression_ReferenceSegmentDefaultTypeInternal {
+  constexpr Expression_ReferenceSegmentDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_ReferenceSegmentDefaultTypeInternal() {}
+  union {
+    Expression_ReferenceSegment _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegmentDefaultTypeInternal _Expression_ReferenceSegment_default_instance_;
+constexpr Expression_MaskExpression_Select::Expression_MaskExpression_Select(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct Expression_MaskExpression_SelectDefaultTypeInternal {
+  constexpr Expression_MaskExpression_SelectDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MaskExpression_SelectDefaultTypeInternal() {}
+  union {
+    Expression_MaskExpression_Select _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_SelectDefaultTypeInternal _Expression_MaskExpression_Select_default_instance_;
+constexpr Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : struct_items_(){}
+struct Expression_MaskExpression_StructSelectDefaultTypeInternal {
+  constexpr Expression_MaskExpression_StructSelectDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MaskExpression_StructSelectDefaultTypeInternal() {}
+  union {
+    Expression_MaskExpression_StructSelect _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_StructSelectDefaultTypeInternal _Expression_MaskExpression_StructSelect_default_instance_;
+constexpr Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : child_(nullptr)
+  , field_(0){}
+struct Expression_MaskExpression_StructItemDefaultTypeInternal {
+  constexpr Expression_MaskExpression_StructItemDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MaskExpression_StructItemDefaultTypeInternal() {}
+  union {
+    Expression_MaskExpression_StructItem _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_StructItemDefaultTypeInternal _Expression_MaskExpression_StructItem_default_instance_;
+constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : field_(0){}
+struct Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal {
+  constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal() {}
+  union {
+    Expression_MaskExpression_ListSelect_ListSelectItem_ListElement _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_;
+constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : start_(0)
+  , end_(0){}
+struct Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal {
+  constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal() {}
+  union {
+    Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_;
+constexpr Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal {
+  constexpr Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal() {}
+  union {
+    Expression_MaskExpression_ListSelect_ListSelectItem _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_;
+constexpr Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : selection_()
+  , child_(nullptr){}
+struct Expression_MaskExpression_ListSelectDefaultTypeInternal {
+  constexpr Expression_MaskExpression_ListSelectDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MaskExpression_ListSelectDefaultTypeInternal() {}
+  union {
+    Expression_MaskExpression_ListSelect _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelectDefaultTypeInternal _Expression_MaskExpression_ListSelect_default_instance_;
+constexpr Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : map_key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal {
+  constexpr Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal() {}
+  union {
+    Expression_MaskExpression_MapSelect_MapKey _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKey_default_instance_;
+constexpr Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : map_key_expression_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal {
+  constexpr Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal() {}
+  union {
+    Expression_MaskExpression_MapSelect_MapKeyExpression _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_;
+constexpr Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : child_(nullptr)
+  , _oneof_case_{}{}
+struct Expression_MaskExpression_MapSelectDefaultTypeInternal {
+  constexpr Expression_MaskExpression_MapSelectDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MaskExpression_MapSelectDefaultTypeInternal() {}
+  union {
+    Expression_MaskExpression_MapSelect _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_MapSelectDefaultTypeInternal _Expression_MaskExpression_MapSelect_default_instance_;
+constexpr Expression_MaskExpression::Expression_MaskExpression(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : select_(nullptr)
+  , maintain_singular_struct_(false){}
+struct Expression_MaskExpressionDefaultTypeInternal {
+  constexpr Expression_MaskExpressionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_MaskExpressionDefaultTypeInternal() {}
+  union {
+    Expression_MaskExpression _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpressionDefaultTypeInternal _Expression_MaskExpression_default_instance_;
+constexpr Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
+struct Expression_FieldReference_RootReferenceDefaultTypeInternal {
+  constexpr Expression_FieldReference_RootReferenceDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_FieldReference_RootReferenceDefaultTypeInternal() {}
+  union {
+    Expression_FieldReference_RootReference _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_FieldReference_RootReferenceDefaultTypeInternal _Expression_FieldReference_RootReference_default_instance_;
+constexpr Expression_FieldReference::Expression_FieldReference(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct Expression_FieldReferenceDefaultTypeInternal {
+  constexpr Expression_FieldReferenceDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Expression_FieldReferenceDefaultTypeInternal() {}
+  union {
+    Expression_FieldReference _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_FieldReferenceDefaultTypeInternal _Expression_FieldReference_default_instance_;
+constexpr Expression::Expression(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct ExpressionDefaultTypeInternal {
+  constexpr ExpressionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ExpressionDefaultTypeInternal() {}
+  union {
+    Expression _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExpressionDefaultTypeInternal _Expression_default_instance_;
+constexpr SortField::SortField(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : expr_(nullptr)
+  , _oneof_case_{}{}
+struct SortFieldDefaultTypeInternal {
+  constexpr SortFieldDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~SortFieldDefaultTypeInternal() {}
+  union {
+    SortField _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SortFieldDefaultTypeInternal _SortField_default_instance_;
+constexpr AggregateFunction::AggregateFunction(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : args_()
+  , sorts_()
+  , output_type_(nullptr)
+  , function_reference_(0u)
+  , phase_(0)
+{}
+struct AggregateFunctionDefaultTypeInternal {
+  constexpr AggregateFunctionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~AggregateFunctionDefaultTypeInternal() {}
+  union {
+    AggregateFunction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateFunctionDefaultTypeInternal _AggregateFunction_default_instance_;
+}  // namespace substrait
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fexpression_2eproto[49];
+static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2fexpression_2eproto[2];
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fexpression_2eproto = nullptr;
+
+const uint32_t TableStruct_substrait_2fexpression_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum_Empty, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, enum_kind_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, value_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, length_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, value_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, precision_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, scale_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, key_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, value_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map, key_values_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, years_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, months_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, days_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, seconds_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Struct, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Struct, fields_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_List, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_List, values_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, nullable_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, literal_type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, function_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, args_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, output_type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Preceding, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Preceding, offset_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Following, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Following, offset_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_CurrentRow, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Unbounded, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, kind_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, function_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, partitions_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, sorts_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, upper_bound_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, lower_bound_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, phase_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, output_type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, args_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, if__),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, then_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, ifs_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, else__),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, input_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, if__),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, then_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, ifs_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, else__),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, value_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, options_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList_Record, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList_Record, fields_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, value_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, options_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, function_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, prerequisite_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, script_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, prerequisite_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, arguments_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, output_type_),
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, kind_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, map_key_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, child_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, field_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, child_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, offset_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, child_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, reference_type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructSelect, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructSelect, struct_items_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, field_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, child_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, field_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, start_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, end_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, selection_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, child_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKey, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKey, map_key_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, map_key_expression_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, child_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, select_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, select_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, maintain_singular_struct_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference_RootReference, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, reference_type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, root_type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::Expression, rex_type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::SortField, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::SortField, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::SortField, expr_),
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::SortField, sort_kind_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, function_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, args_),
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, sorts_),
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, phase_),
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, output_type_),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, -1, sizeof(::substrait::Expression_Enum_Empty)},
+  { 6, -1, -1, sizeof(::substrait::Expression_Enum)},
+  { 15, -1, -1, sizeof(::substrait::Expression_Literal_VarChar)},
+  { 23, -1, -1, sizeof(::substrait::Expression_Literal_Decimal)},
+  { 32, -1, -1, sizeof(::substrait::Expression_Literal_Map_KeyValue)},
+  { 40, -1, -1, sizeof(::substrait::Expression_Literal_Map)},
+  { 47, -1, -1, sizeof(::substrait::Expression_Literal_IntervalYearToMonth)},
+  { 55, -1, -1, sizeof(::substrait::Expression_Literal_IntervalDayToSecond)},
+  { 63, -1, -1, sizeof(::substrait::Expression_Literal_Struct)},
+  { 70, -1, -1, sizeof(::substrait::Expression_Literal_List)},
+  { 77, -1, -1, sizeof(::substrait::Expression_Literal)},
+  { 111, -1, -1, sizeof(::substrait::Expression_ScalarFunction)},
+  { 120, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Preceding)},
+  { 127, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Following)},
+  { 134, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_CurrentRow)},
+  { 140, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Unbounded)},
+  { 146, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound)},
+  { 157, -1, -1, sizeof(::substrait::Expression_WindowFunction)},
+  { 171, -1, -1, sizeof(::substrait::Expression_IfThen_IfClause)},
+  { 179, -1, -1, sizeof(::substrait::Expression_IfThen)},
+  { 187, -1, -1, sizeof(::substrait::Expression_Cast)},
+  { 195, -1, -1, sizeof(::substrait::Expression_SwitchExpression_IfValue)},
+  { 203, -1, -1, sizeof(::substrait::Expression_SwitchExpression)},
+  { 211, -1, -1, sizeof(::substrait::Expression_SingularOrList)},
+  { 219, -1, -1, sizeof(::substrait::Expression_MultiOrList_Record)},
+  { 226, -1, -1, sizeof(::substrait::Expression_MultiOrList)},
+  { 234, -1, -1, sizeof(::substrait::Expression_EmbeddedFunction_PythonPickleFunction)},
+  { 242, -1, -1, sizeof(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction)},
+  { 250, -1, -1, sizeof(::substrait::Expression_EmbeddedFunction)},
+  { 261, -1, -1, sizeof(::substrait::Expression_ReferenceSegment_MapKey)},
+  { 269, -1, -1, sizeof(::substrait::Expression_ReferenceSegment_StructField)},
+  { 277, -1, -1, sizeof(::substrait::Expression_ReferenceSegment_ListElement)},
+  { 285, -1, -1, sizeof(::substrait::Expression_ReferenceSegment)},
+  { 295, -1, -1, sizeof(::substrait::Expression_MaskExpression_Select)},
+  { 305, -1, -1, sizeof(::substrait::Expression_MaskExpression_StructSelect)},
+  { 312, -1, -1, sizeof(::substrait::Expression_MaskExpression_StructItem)},
+  { 320, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement)},
+  { 327, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice)},
+  { 335, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem)},
+  { 344, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect)},
+  { 352, -1, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect_MapKey)},
+  { 359, -1, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression)},
+  { 366, -1, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect)},
+  { 376, -1, -1, sizeof(::substrait::Expression_MaskExpression)},
+  { 384, -1, -1, sizeof(::substrait::Expression_FieldReference_RootReference)},
+  { 390, -1, -1, sizeof(::substrait::Expression_FieldReference)},
+  { 402, -1, -1, sizeof(::substrait::Expression)},
+  { 419, -1, -1, sizeof(::substrait::SortField)},
+  { 429, -1, -1, sizeof(::substrait::AggregateFunction)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Enum_Empty_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Enum_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_VarChar_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_Decimal_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_Map_KeyValue_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_Map_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_Struct_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_List_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Literal_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_ScalarFunction_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_WindowFunction_Bound_Following_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_WindowFunction_Bound_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_WindowFunction_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_IfThen_IfClause_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_IfThen_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_Cast_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_SwitchExpression_IfValue_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_SwitchExpression_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_SingularOrList_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MultiOrList_Record_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MultiOrList_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_EmbeddedFunction_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_ReferenceSegment_MapKey_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_ReferenceSegment_StructField_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_ReferenceSegment_ListElement_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_ReferenceSegment_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_Select_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_StructSelect_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_StructItem_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_ListSelect_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_MapSelect_MapKey_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_MapSelect_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_MaskExpression_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_FieldReference_RootReference_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_FieldReference_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Expression_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_SortField_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_AggregateFunction_default_instance_),
+};
+
+const char descriptor_table_protodef_substrait_2fexpression_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\032substrait/expression.proto\022\tsubstrait\032"
+  "\024substrait/type.proto\"\2101\n\nExpression\0220\n\007"
+  "literal\030\001 \001(\0132\035.substrait.Expression.Lit"
+  "eralH\000\0229\n\tselection\030\002 \001(\0132$.substrait.Ex"
+  "pression.FieldReferenceH\000\022\?\n\017scalar_func"
+  "tion\030\003 \001(\0132$.substrait.Expression.Scalar"
+  "FunctionH\000\022\?\n\017window_function\030\005 \001(\0132$.su"
+  "bstrait.Expression.WindowFunctionH\000\022/\n\007i"
+  "f_then\030\006 \001(\0132\034.substrait.Expression.IfTh"
+  "enH\000\022C\n\021switch_expression\030\007 \001(\0132&.substr"
+  "ait.Expression.SwitchExpressionH\000\022@\n\020sin"
+  "gular_or_list\030\010 \001(\0132$.substrait.Expressi"
+  "on.SingularOrListH\000\022:\n\rmulti_or_list\030\t \001"
+  "(\0132!.substrait.Expression.MultiOrListH\000\022"
+  "*\n\004enum\030\n \001(\0132\032.substrait.Expression.Enu"
+  "mH\000\022*\n\004cast\030\013 \001(\0132\032.substrait.Expression"
+  ".CastH\000\032j\n\004Enum\022\023\n\tspecified\030\001 \001(\tH\000\0227\n\013"
+  "unspecified\030\002 \001(\0132 .substrait.Expression"
+  ".Enum.EmptyH\000\032\007\n\005EmptyB\013\n\tenum_kind\032\354\n\n\007"
+  "Literal\022\021\n\007boolean\030\001 \001(\010H\000\022\014\n\002i8\030\002 \001(\005H\000"
+  "\022\r\n\003i16\030\003 \001(\005H\000\022\r\n\003i32\030\005 \001(\005H\000\022\r\n\003i64\030\007 "
+  "\001(\003H\000\022\016\n\004fp32\030\n \001(\002H\000\022\016\n\004fp64\030\013 \001(\001H\000\022\020\n"
+  "\006string\030\014 \001(\tH\000\022\020\n\006binary\030\r \001(\014H\000\022\023\n\ttim"
+  "estamp\030\016 \001(\003H\000\022\016\n\004date\030\020 \001(\005H\000\022\016\n\004time\030\021"
+  " \001(\003H\000\022S\n\026interval_year_to_month\030\023 \001(\01321"
+  ".substrait.Expression.Literal.IntervalYe"
+  "arToMonthH\000\022S\n\026interval_day_to_second\030\024 "
+  "\001(\01321.substrait.Expression.Literal.Inter"
+  "valDayToSecondH\000\022\024\n\nfixed_char\030\025 \001(\tH\000\0229"
+  "\n\010var_char\030\026 \001(\0132%.substrait.Expression."
+  "Literal.VarCharH\000\022\026\n\014fixed_binary\030\027 \001(\014H"
+  "\000\0228\n\007decimal\030\030 \001(\0132%.substrait.Expressio"
+  "n.Literal.DecimalH\000\0226\n\006struct\030\031 \001(\0132$.su"
+  "bstrait.Expression.Literal.StructH\000\0220\n\003m"
+  "ap\030\032 \001(\0132!.substrait.Expression.Literal."
+  "MapH\000\022\026\n\014timestamp_tz\030\033 \001(\003H\000\022\016\n\004uuid\030\034 "
+  "\001(\014H\000\022\037\n\004null\030\035 \001(\0132\017.substrait.TypeH\000\0222"
+  "\n\004list\030\036 \001(\0132\".substrait.Expression.Lite"
+  "ral.ListH\000\022*\n\nempty_list\030\037 \001(\0132\024.substra"
+  "it.Type.ListH\000\022(\n\tempty_map\030  \001(\0132\023.subs"
+  "trait.Type.MapH\000\022\020\n\010nullable\0302 \001(\010\032(\n\007Va"
+  "rChar\022\r\n\005value\030\001 \001(\t\022\016\n\006length\030\002 \001(\r\032:\n\007"
+  "Decimal\022\r\n\005value\030\001 \001(\014\022\021\n\tprecision\030\002 \001("
+  "\005\022\r\n\005scale\030\003 \001(\005\032\253\001\n\003Map\022>\n\nkey_values\030\001"
+  " \003(\0132*.substrait.Expression.Literal.Map."
+  "KeyValue\032d\n\010KeyValue\022*\n\003key\030\001 \001(\0132\035.subs"
+  "trait.Expression.Literal\022,\n\005value\030\002 \001(\0132"
+  "\035.substrait.Expression.Literal\0324\n\023Interv"
+  "alYearToMonth\022\r\n\005years\030\001 \001(\005\022\016\n\006months\030\002"
+  " \001(\005\0324\n\023IntervalDayToSecond\022\014\n\004days\030\001 \001("
+  "\005\022\017\n\007seconds\030\002 \001(\005\0327\n\006Struct\022-\n\006fields\030\001"
+  " \003(\0132\035.substrait.Expression.Literal\0325\n\004L"
+  "ist\022-\n\006values\030\001 \003(\0132\035.substrait.Expressi"
+  "on.LiteralB\016\n\014literal_type\032w\n\016ScalarFunc"
+  "tion\022\032\n\022function_reference\030\001 \001(\r\022#\n\004args"
+  "\030\002 \003(\0132\025.substrait.Expression\022$\n\013output_"
+  "type\030\003 \001(\0132\017.substrait.Type\032\213\006\n\016WindowFu"
+  "nction\022\032\n\022function_reference\030\001 \001(\r\022)\n\npa"
+  "rtitions\030\002 \003(\0132\025.substrait.Expression\022#\n"
+  "\005sorts\030\003 \003(\0132\024.substrait.SortField\022\?\n\013up"
+  "per_bound\030\004 \001(\0132*.substrait.Expression.W"
+  "indowFunction.Bound\022\?\n\013lower_bound\030\005 \001(\013"
+  "2*.substrait.Expression.WindowFunction.B"
+  "ound\022*\n\005phase\030\006 \001(\0162\033.substrait.Aggregat"
+  "ionPhase\022$\n\013output_type\030\007 \001(\0132\017.substrai"
+  "t.Type\022#\n\004args\030\010 \003(\0132\025.substrait.Express"
+  "ion\032\223\003\n\005Bound\022I\n\tpreceding\030\001 \001(\01324.subst"
+  "rait.Expression.WindowFunction.Bound.Pre"
+  "cedingH\000\022I\n\tfollowing\030\002 \001(\01324.substrait."
+  "Expression.WindowFunction.Bound.Followin"
+  "gH\000\022L\n\013current_row\030\003 \001(\01325.substrait.Exp"
+  "ression.WindowFunction.Bound.CurrentRowH"
+  "\000\022I\n\tunbounded\030\004 \001(\01324.substrait.Express"
+  "ion.WindowFunction.Bound.UnboundedH\000\032\033\n\t"
+  "Preceding\022\016\n\006offset\030\001 \001(\003\032\033\n\tFollowing\022\016"
+  "\n\006offset\030\001 \001(\003\032\014\n\nCurrentRow\032\013\n\tUnbounde"
+  "dB\006\n\004kind\032\265\001\n\006IfThen\0222\n\003ifs\030\001 \003(\0132%.subs"
+  "trait.Expression.IfThen.IfClause\022#\n\004else"
+  "\030\002 \001(\0132\025.substrait.Expression\032R\n\010IfClaus"
+  "e\022!\n\002if\030\001 \001(\0132\025.substrait.Expression\022#\n\004"
+  "then\030\002 \001(\0132\025.substrait.Expression\032K\n\004Cas"
+  "t\022\035\n\004type\030\001 \001(\0132\017.substrait.Type\022$\n\005inpu"
+  "t\030\002 \001(\0132\025.substrait.Expression\032\317\001\n\020Switc"
+  "hExpression\022;\n\003ifs\030\001 \003(\0132..substrait.Exp"
+  "ression.SwitchExpression.IfValue\022#\n\004else"
+  "\030\002 \001(\0132\025.substrait.Expression\032Y\n\007IfValue"
+  "\022)\n\002if\030\001 \001(\0132\035.substrait.Expression.Lite"
+  "ral\022#\n\004then\030\002 \001(\0132\025.substrait.Expression"
+  "\032^\n\016SingularOrList\022$\n\005value\030\001 \001(\0132\025.subs"
+  "trait.Expression\022&\n\007options\030\002 \003(\0132\025.subs"
+  "trait.Expression\032\237\001\n\013MultiOrList\022$\n\005valu"
+  "e\030\001 \003(\0132\025.substrait.Expression\0229\n\007option"
+  "s\030\002 \003(\0132(.substrait.Expression.MultiOrLi"
+  "st.Record\032/\n\006Record\022%\n\006fields\030\001 \003(\0132\025.su"
+  "bstrait.Expression\032\243\003\n\020EmbeddedFunction\022"
+  "(\n\targuments\030\001 \003(\0132\025.substrait.Expressio"
+  "n\022$\n\013output_type\030\002 \001(\0132\017.substrait.Type\022"
+  "]\n\026python_pickle_function\030\003 \001(\0132;.substr"
+  "ait.Expression.EmbeddedFunction.PythonPi"
+  "ckleFunctionH\000\022[\n\025web_assembly_function\030"
+  "\004 \001(\0132:.substrait.Expression.EmbeddedFun"
+  "ction.WebAssemblyFunctionH\000\032>\n\024PythonPic"
+  "kleFunction\022\020\n\010function\030\001 \001(\014\022\024\n\014prerequ"
+  "isite\030\002 \003(\t\032;\n\023WebAssemblyFunction\022\016\n\006sc"
+  "ript\030\001 \001(\014\022\024\n\014prerequisite\030\002 \003(\tB\006\n\004kind"
+  "\032\232\004\n\020ReferenceSegment\022@\n\007map_key\030\001 \001(\0132-"
+  ".substrait.Expression.ReferenceSegment.M"
+  "apKeyH\000\022J\n\014struct_field\030\002 \001(\01322.substrai"
+  "t.Expression.ReferenceSegment.StructFiel"
+  "dH\000\022J\n\014list_element\030\003 \001(\01322.substrait.Ex"
+  "pression.ReferenceSegment.ListElementH\000\032"
+  "o\n\006MapKey\022.\n\007map_key\030\001 \001(\0132\035.substrait.E"
+  "xpression.Literal\0225\n\005child\030\002 \001(\0132&.subst"
+  "rait.Expression.ReferenceSegment\032S\n\013Stru"
+  "ctField\022\r\n\005field\030\001 \001(\005\0225\n\005child\030\002 \001(\0132&."
+  "substrait.Expression.ReferenceSegment\032T\n"
+  "\013ListElement\022\016\n\006offset\030\001 \001(\005\0225\n\005child\030\002 "
+  "\001(\0132&.substrait.Expression.ReferenceSegm"
+  "entB\020\n\016reference_type\032\360\t\n\016MaskExpression"
+  "\022A\n\006select\030\001 \001(\01321.substrait.Expression."
+  "MaskExpression.StructSelect\022 \n\030maintain_"
+  "singular_struct\030\002 \001(\010\032\325\001\n\006Select\022C\n\006stru"
+  "ct\030\001 \001(\01321.substrait.Expression.MaskExpr"
+  "ession.StructSelectH\000\022\?\n\004list\030\002 \001(\0132/.su"
+  "bstrait.Expression.MaskExpression.ListSe"
+  "lectH\000\022=\n\003map\030\003 \001(\0132..substrait.Expressi"
+  "on.MaskExpression.MapSelectH\000B\006\n\004type\032U\n"
+  "\014StructSelect\022E\n\014struct_items\030\001 \003(\0132/.su"
+  "bstrait.Expression.MaskExpression.Struct"
+  "Item\032W\n\nStructItem\022\r\n\005field\030\001 \001(\005\022:\n\005chi"
+  "ld\030\002 \001(\0132+.substrait.Expression.MaskExpr"
+  "ession.Select\032\264\003\n\nListSelect\022Q\n\tselectio"
+  "n\030\001 \003(\0132>.substrait.Expression.MaskExpre"
+  "ssion.ListSelect.ListSelectItem\022:\n\005child"
+  "\030\002 \001(\0132+.substrait.Expression.MaskExpres"
+  "sion.Select\032\226\002\n\016ListSelectItem\022Z\n\004item\030\001"
+  " \001(\0132J.substrait.Expression.MaskExpressi"
+  "on.ListSelect.ListSelectItem.ListElement"
+  "H\000\022Y\n\005slice\030\002 \001(\0132H.substrait.Expression"
+  ".MaskExpression.ListSelect.ListSelectIte"
+  "m.ListSliceH\000\032\034\n\013ListElement\022\r\n\005field\030\001 "
+  "\001(\005\032\'\n\tListSlice\022\r\n\005start\030\001 \001(\005\022\013\n\003end\030\002"
+  " \001(\005B\006\n\004type\032\271\002\n\tMapSelect\022D\n\003key\030\001 \001(\0132"
+  "5.substrait.Expression.MaskExpression.Ma"
+  "pSelect.MapKeyH\000\022U\n\nexpression\030\002 \001(\0132\?.s"
+  "ubstrait.Expression.MaskExpression.MapSe"
+  "lect.MapKeyExpressionH\000\022:\n\005child\030\003 \001(\0132+"
+  ".substrait.Expression.MaskExpression.Sel"
+  "ect\032\031\n\006MapKey\022\017\n\007map_key\030\001 \001(\t\032.\n\020MapKey"
+  "Expression\022\032\n\022map_key_expression\030\001 \001(\tB\010"
+  "\n\006select\032\301\002\n\016FieldReference\022B\n\020direct_re"
+  "ference\030\001 \001(\0132&.substrait.Expression.Ref"
+  "erenceSegmentH\000\022@\n\020masked_reference\030\002 \001("
+  "\0132$.substrait.Expression.MaskExpressionH"
+  "\000\022+\n\nexpression\030\003 \001(\0132\025.substrait.Expres"
+  "sionH\001\022L\n\016root_reference\030\004 \001(\01322.substra"
+  "it.Expression.FieldReference.RootReferen"
+  "ceH\001\032\017\n\rRootReferenceB\020\n\016reference_typeB"
+  "\013\n\troot_typeB\n\n\010rex_type\"\377\002\n\tSortField\022#"
+  "\n\004expr\030\001 \001(\0132\025.substrait.Expression\0227\n\td"
+  "irection\030\002 \001(\0162\".substrait.SortField.Sor"
+  "tDirectionH\000\022\'\n\035comparison_function_refe"
+  "rence\030\003 \001(\rH\000\"\335\001\n\rSortDirection\022\036\n\032SORT_"
+  "DIRECTION_UNSPECIFIED\020\000\022\"\n\036SORT_DIRECTIO"
+  "N_ASC_NULLS_FIRST\020\001\022!\n\035SORT_DIRECTION_AS"
+  "C_NULLS_LAST\020\002\022#\n\037SORT_DIRECTION_DESC_NU"
+  "LLS_FIRST\020\003\022\"\n\036SORT_DIRECTION_DESC_NULLS"
+  "_LAST\020\004\022\034\n\030SORT_DIRECTION_CLUSTERED\020\005B\013\n"
+  "\tsort_kind\"\313\001\n\021AggregateFunction\022\032\n\022func"
+  "tion_reference\030\001 \001(\r\022#\n\004args\030\002 \003(\0132\025.sub"
+  "strait.Expression\022#\n\005sorts\030\003 \003(\0132\024.subst"
+  "rait.SortField\022*\n\005phase\030\004 \001(\0162\033.substrai"
+  "t.AggregationPhase\022$\n\013output_type\030\005 \001(\0132"
+  "\017.substrait.Type*\357\001\n\020AggregationPhase\022!\n"
+  "\035AGGREGATION_PHASE_UNSPECIFIED\020\000\022-\n)AGGR"
+  "EGATION_PHASE_INITIAL_TO_INTERMEDIATE\020\001\022"
+  "2\n.AGGREGATION_PHASE_INTERMEDIATE_TO_INT"
+  "ERMEDIATE\020\002\022\'\n#AGGREGATION_PHASE_INITIAL"
+  "_TO_RESULT\020\003\022,\n(AGGREGATION_PHASE_INTERM"
+  "EDIATE_TO_RESULT\020\004B+\n\022io.substrait.proto"
+  "P\001\252\002\022Substrait.Protobufb\006proto3"
+  ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2fexpression_2eproto_deps[1] = {
+  &::descriptor_table_substrait_2ftype_2eproto,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fexpression_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fexpression_2eproto = {
+  false, false, 7231, descriptor_table_protodef_substrait_2fexpression_2eproto, "substrait/expression.proto", 
+  &descriptor_table_substrait_2fexpression_2eproto_once, descriptor_table_substrait_2fexpression_2eproto_deps, 1, 49,
+  schemas, file_default_instances, TableStruct_substrait_2fexpression_2eproto::offsets,
+  file_level_metadata_substrait_2fexpression_2eproto, file_level_enum_descriptors_substrait_2fexpression_2eproto, file_level_service_descriptors_substrait_2fexpression_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fexpression_2eproto_getter() {
+  return &descriptor_table_substrait_2fexpression_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fexpression_2eproto(&descriptor_table_substrait_2fexpression_2eproto);
+namespace substrait {
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortField_SortDirection_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2fexpression_2eproto);
+  return file_level_enum_descriptors_substrait_2fexpression_2eproto[0];
+}
+bool SortField_SortDirection_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr SortField_SortDirection SortField::SORT_DIRECTION_UNSPECIFIED;
+constexpr SortField_SortDirection SortField::SORT_DIRECTION_ASC_NULLS_FIRST;
+constexpr SortField_SortDirection SortField::SORT_DIRECTION_ASC_NULLS_LAST;
+constexpr SortField_SortDirection SortField::SORT_DIRECTION_DESC_NULLS_FIRST;
+constexpr SortField_SortDirection SortField::SORT_DIRECTION_DESC_NULLS_LAST;
+constexpr SortField_SortDirection SortField::SORT_DIRECTION_CLUSTERED;
+constexpr SortField_SortDirection SortField::SortDirection_MIN;
+constexpr SortField_SortDirection SortField::SortDirection_MAX;
+constexpr int SortField::SortDirection_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggregationPhase_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2fexpression_2eproto);
+  return file_level_enum_descriptors_substrait_2fexpression_2eproto[1];
+}
+bool AggregationPhase_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+class Expression_Enum_Empty::_Internal {
+ public:
+};
+
+Expression_Enum_Empty::Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Enum.Empty)
+}
+Expression_Enum_Empty::Expression_Enum_Empty(const Expression_Enum_Empty& from)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Enum.Empty)
+}
+
+
+
+
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Enum_Empty::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Enum_Empty::GetClassData() const { return &_class_data_; }
+
+
+
+
+
+
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_Enum_Empty::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[0]);
+}
+
+// ===================================================================
+
+class Expression_Enum::_Internal {
+ public:
+  static const ::substrait::Expression_Enum_Empty& unspecified(const Expression_Enum* msg);
+};
+
+const ::substrait::Expression_Enum_Empty&
+Expression_Enum::_Internal::unspecified(const Expression_Enum* msg) {
+  return *msg->enum_kind_.unspecified_;
+}
+void Expression_Enum::set_allocated_unspecified(::substrait::Expression_Enum_Empty* unspecified) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_enum_kind();
+  if (unspecified) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Enum_Empty>::GetOwningArena(unspecified);
+    if (message_arena != submessage_arena) {
+      unspecified = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, unspecified, submessage_arena);
+    }
+    set_has_unspecified();
+    enum_kind_.unspecified_ = unspecified;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Enum.unspecified)
+}
+Expression_Enum::Expression_Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Enum)
+}
+Expression_Enum::Expression_Enum(const Expression_Enum& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_enum_kind();
+  switch (from.enum_kind_case()) {
+    case kSpecified: {
+      _internal_set_specified(from._internal_specified());
+      break;
+    }
+    case kUnspecified: {
+      _internal_mutable_unspecified()->::substrait::Expression_Enum_Empty::MergeFrom(from._internal_unspecified());
+      break;
+    }
+    case ENUM_KIND_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Enum)
+}
+
+inline void Expression_Enum::SharedCtor() {
+clear_has_enum_kind();
+}
+
+Expression_Enum::~Expression_Enum() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.Enum)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_Enum::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_enum_kind()) {
+    clear_enum_kind();
+  }
+}
+
+void Expression_Enum::ArenaDtor(void* object) {
+  Expression_Enum* _this = reinterpret_cast< Expression_Enum* >(object);
+  (void)_this;
+}
+void Expression_Enum::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_Enum::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_Enum::clear_enum_kind() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.Enum)
+  switch (enum_kind_case()) {
+    case kSpecified: {
+      enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+      break;
+    }
+    case kUnspecified: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete enum_kind_.unspecified_;
+      }
+      break;
+    }
+    case ENUM_KIND_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = ENUM_KIND_NOT_SET;
+}
+
+
+void Expression_Enum::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.Enum)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_enum_kind();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_Enum::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string specified = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_specified();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Enum.specified"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.Enum.Empty unspecified = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_unspecified(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_Enum::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Enum)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string specified = 1;
+  if (_internal_has_specified()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_specified().data(), static_cast<int>(this->_internal_specified().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Expression.Enum.specified");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_specified(), target);
+  }
+
+  // .substrait.Expression.Enum.Empty unspecified = 2;
+  if (_internal_has_unspecified()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::unspecified(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Enum)
+  return target;
+}
+
+size_t Expression_Enum::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Enum)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (enum_kind_case()) {
+    // string specified = 1;
+    case kSpecified: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_specified());
+      break;
+    }
+    // .substrait.Expression.Enum.Empty unspecified = 2;
+    case kUnspecified: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *enum_kind_.unspecified_);
+      break;
+    }
+    case ENUM_KIND_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Enum::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_Enum::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Enum::GetClassData() const { return &_class_data_; }
+
+void Expression_Enum::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_Enum *>(to)->MergeFrom(
+      static_cast<const Expression_Enum &>(from));
+}
+
+
+void Expression_Enum::MergeFrom(const Expression_Enum& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Enum)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.enum_kind_case()) {
+    case kSpecified: {
+      _internal_set_specified(from._internal_specified());
+      break;
+    }
+    case kUnspecified: {
+      _internal_mutable_unspecified()->::substrait::Expression_Enum_Empty::MergeFrom(from._internal_unspecified());
+      break;
+    }
+    case ENUM_KIND_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_Enum::CopyFrom(const Expression_Enum& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Enum)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_Enum::IsInitialized() const {
+  return true;
+}
+
+void Expression_Enum::InternalSwap(Expression_Enum* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(enum_kind_, other->enum_kind_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_Enum::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[1]);
+}
+
+// ===================================================================
+
+class Expression_Literal_VarChar::_Internal {
+ public:
+};
+
+Expression_Literal_VarChar::Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.VarChar)
+}
+Expression_Literal_VarChar::Expression_Literal_VarChar(const Expression_Literal_VarChar& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_value().empty()) {
+    value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), 
+      GetArenaForAllocation());
+  }
+  length_ = from.length_;
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.VarChar)
+}
+
+inline void Expression_Literal_VarChar::SharedCtor() {
+value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+length_ = 0u;
+}
+
+Expression_Literal_VarChar::~Expression_Literal_VarChar() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.Literal.VarChar)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_Literal_VarChar::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Expression_Literal_VarChar::ArenaDtor(void* object) {
+  Expression_Literal_VarChar* _this = reinterpret_cast< Expression_Literal_VarChar* >(object);
+  (void)_this;
+}
+void Expression_Literal_VarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_Literal_VarChar::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_Literal_VarChar::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.VarChar)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  value_.ClearToEmpty();
+  length_ = 0u;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_Literal_VarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string value = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_value();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.VarChar.value"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 length = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_Literal_VarChar::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.VarChar)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string value = 1;
+  if (!this->_internal_value().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_value().data(), static_cast<int>(this->_internal_value().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Expression.Literal.VarChar.value");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_value(), target);
+  }
+
+  // uint32 length = 2;
+  if (this->_internal_length() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_length(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.VarChar)
+  return target;
+}
+
+size_t Expression_Literal_VarChar::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.VarChar)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string value = 1;
+  if (!this->_internal_value().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_value());
+  }
+
+  // uint32 length = 2;
+  if (this->_internal_length() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_length());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_VarChar::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_Literal_VarChar::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_VarChar::GetClassData() const { return &_class_data_; }
+
+void Expression_Literal_VarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_Literal_VarChar *>(to)->MergeFrom(
+      static_cast<const Expression_Literal_VarChar &>(from));
+}
+
+
+void Expression_Literal_VarChar::MergeFrom(const Expression_Literal_VarChar& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.VarChar)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_value().empty()) {
+    _internal_set_value(from._internal_value());
+  }
+  if (from._internal_length() != 0) {
+    _internal_set_length(from._internal_length());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_Literal_VarChar::CopyFrom(const Expression_Literal_VarChar& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.VarChar)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_Literal_VarChar::IsInitialized() const {
+  return true;
+}
+
+void Expression_Literal_VarChar::InternalSwap(Expression_Literal_VarChar* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &value_, lhs_arena,
+      &other->value_, rhs_arena
+  );
+  swap(length_, other->length_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_VarChar::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[2]);
+}
+
+// ===================================================================
+
+class Expression_Literal_Decimal::_Internal {
+ public:
+};
+
+Expression_Literal_Decimal::Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Decimal)
+}
+Expression_Literal_Decimal::Expression_Literal_Decimal(const Expression_Literal_Decimal& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_value().empty()) {
+    value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), 
+      GetArenaForAllocation());
+  }
+  ::memcpy(&precision_, &from.precision_,
+    static_cast<size_t>(reinterpret_cast<char*>(&scale_) -
+    reinterpret_cast<char*>(&precision_)) + sizeof(scale_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Decimal)
+}
+
+inline void Expression_Literal_Decimal::SharedCtor() {
+value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&precision_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&scale_) -
+    reinterpret_cast<char*>(&precision_)) + sizeof(scale_));
+}
+
+Expression_Literal_Decimal::~Expression_Literal_Decimal() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Decimal)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_Literal_Decimal::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Expression_Literal_Decimal::ArenaDtor(void* object) {
+  Expression_Literal_Decimal* _this = reinterpret_cast< Expression_Literal_Decimal* >(object);
+  (void)_this;
+}
+void Expression_Literal_Decimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_Literal_Decimal::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_Literal_Decimal::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Decimal)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  value_.ClearToEmpty();
+  ::memset(&precision_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&scale_) -
+      reinterpret_cast<char*>(&precision_)) + sizeof(scale_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_Literal_Decimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // bytes value = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_value();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 precision = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          precision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 scale = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          scale_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_Literal_Decimal::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Decimal)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes value = 1;
+  if (!this->_internal_value().empty()) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_value(), target);
+  }
+
+  // int32 precision = 2;
+  if (this->_internal_precision() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_precision(), target);
+  }
+
+  // int32 scale = 3;
+  if (this->_internal_scale() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_scale(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.Decimal)
+  return target;
+}
+
+size_t Expression_Literal_Decimal::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Decimal)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // bytes value = 1;
+  if (!this->_internal_value().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_value());
+  }
+
+  // int32 precision = 2;
+  if (this->_internal_precision() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_precision());
+  }
+
+  // int32 scale = 3;
+  if (this->_internal_scale() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_scale());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_Decimal::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_Literal_Decimal::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_Decimal::GetClassData() const { return &_class_data_; }
+
+void Expression_Literal_Decimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_Literal_Decimal *>(to)->MergeFrom(
+      static_cast<const Expression_Literal_Decimal &>(from));
+}
+
+
+void Expression_Literal_Decimal::MergeFrom(const Expression_Literal_Decimal& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Decimal)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_value().empty()) {
+    _internal_set_value(from._internal_value());
+  }
+  if (from._internal_precision() != 0) {
+    _internal_set_precision(from._internal_precision());
+  }
+  if (from._internal_scale() != 0) {
+    _internal_set_scale(from._internal_scale());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_Literal_Decimal::CopyFrom(const Expression_Literal_Decimal& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Decimal)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_Literal_Decimal::IsInitialized() const {
+  return true;
+}
+
+void Expression_Literal_Decimal::InternalSwap(Expression_Literal_Decimal* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &value_, lhs_arena,
+      &other->value_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_Literal_Decimal, scale_)
+      + sizeof(Expression_Literal_Decimal::scale_)
+      - PROTOBUF_FIELD_OFFSET(Expression_Literal_Decimal, precision_)>(
+          reinterpret_cast<char*>(&precision_),
+          reinterpret_cast<char*>(&other->precision_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Decimal::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[3]);
+}
+
+// ===================================================================
+
+class Expression_Literal_Map_KeyValue::_Internal {
+ public:
+  static const ::substrait::Expression_Literal& key(const Expression_Literal_Map_KeyValue* msg);
+  static const ::substrait::Expression_Literal& value(const Expression_Literal_Map_KeyValue* msg);
+};
+
+const ::substrait::Expression_Literal&
+Expression_Literal_Map_KeyValue::_Internal::key(const Expression_Literal_Map_KeyValue* msg) {
+  return *msg->key_;
+}
+const ::substrait::Expression_Literal&
+Expression_Literal_Map_KeyValue::_Internal::value(const Expression_Literal_Map_KeyValue* msg) {
+  return *msg->value_;
+}
+Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Map.KeyValue)
+}
+Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(const Expression_Literal_Map_KeyValue& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_key()) {
+    key_ = new ::substrait::Expression_Literal(*from.key_);
+  } else {
+    key_ = nullptr;
+  }
+  if (from._internal_has_value()) {
+    value_ = new ::substrait::Expression_Literal(*from.value_);
+  } else {
+    value_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Map.KeyValue)
+}
+
+inline void Expression_Literal_Map_KeyValue::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&key_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&value_) -
+    reinterpret_cast<char*>(&key_)) + sizeof(value_));
+}
+
+Expression_Literal_Map_KeyValue::~Expression_Literal_Map_KeyValue() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Map.KeyValue)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_Literal_Map_KeyValue::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete key_;
+  if (this != internal_default_instance()) delete value_;
+}
+
+void Expression_Literal_Map_KeyValue::ArenaDtor(void* object) {
+  Expression_Literal_Map_KeyValue* _this = reinterpret_cast< Expression_Literal_Map_KeyValue* >(object);
+  (void)_this;
+}
+void Expression_Literal_Map_KeyValue::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_Literal_Map_KeyValue::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_Literal_Map_KeyValue::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Map.KeyValue)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && key_ != nullptr) {
+    delete key_;
+  }
+  key_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && value_ != nullptr) {
+    delete value_;
+  }
+  value_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_Literal_Map_KeyValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression.Literal key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.Literal value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_Literal_Map_KeyValue::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Map.KeyValue)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression.Literal key = 1;
+  if (this->_internal_has_key()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::key(this), target, stream);
+  }
+
+  // .substrait.Expression.Literal value = 2;
+  if (this->_internal_has_value()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::value(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.Map.KeyValue)
+  return target;
+}
+
+size_t Expression_Literal_Map_KeyValue::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Map.KeyValue)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Expression.Literal key = 1;
+  if (this->_internal_has_key()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *key_);
+  }
+
+  // .substrait.Expression.Literal value = 2;
+  if (this->_internal_has_value()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *value_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_Map_KeyValue::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_Literal_Map_KeyValue::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_Map_KeyValue::GetClassData() const { return &_class_data_; }
+
+void Expression_Literal_Map_KeyValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_Literal_Map_KeyValue *>(to)->MergeFrom(
+      static_cast<const Expression_Literal_Map_KeyValue &>(from));
+}
+
+
+void Expression_Literal_Map_KeyValue::MergeFrom(const Expression_Literal_Map_KeyValue& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Map.KeyValue)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_key()) {
+    _internal_mutable_key()->::substrait::Expression_Literal::MergeFrom(from._internal_key());
+  }
+  if (from._internal_has_value()) {
+    _internal_mutable_value()->::substrait::Expression_Literal::MergeFrom(from._internal_value());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_Literal_Map_KeyValue::CopyFrom(const Expression_Literal_Map_KeyValue& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Map.KeyValue)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_Literal_Map_KeyValue::IsInitialized() const {
+  return true;
+}
+
+void Expression_Literal_Map_KeyValue::InternalSwap(Expression_Literal_Map_KeyValue* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_Literal_Map_KeyValue, value_)
+      + sizeof(Expression_Literal_Map_KeyValue::value_)
+      - PROTOBUF_FIELD_OFFSET(Expression_Literal_Map_KeyValue, key_)>(
+          reinterpret_cast<char*>(&key_),
+          reinterpret_cast<char*>(&other->key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map_KeyValue::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[4]);
+}
+
+// ===================================================================
+
+class Expression_Literal_Map::_Internal {
+ public:
+};
+
+Expression_Literal_Map::Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  key_values_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Map)
+}
+Expression_Literal_Map::Expression_Literal_Map(const Expression_Literal_Map& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      key_values_(from.key_values_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Map)
+}
+
+inline void Expression_Literal_Map::SharedCtor() {
+}
+
+Expression_Literal_Map::~Expression_Literal_Map() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Map)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_Literal_Map::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Expression_Literal_Map::ArenaDtor(void* object) {
+  Expression_Literal_Map* _this = reinterpret_cast< Expression_Literal_Map* >(object);
+  (void)_this;
+}
+void Expression_Literal_Map::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_Literal_Map::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_Literal_Map::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Map)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  key_values_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_Literal_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_key_values(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_Literal_Map::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Map)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_key_values_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_key_values(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.Map)
+  return target;
+}
+
+size_t Expression_Literal_Map::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Map)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1;
+  total_size += 1UL * this->_internal_key_values_size();
+  for (const auto& msg : this->key_values_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_Map::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_Literal_Map::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_Map::GetClassData() const { return &_class_data_; }
+
+void Expression_Literal_Map::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_Literal_Map *>(to)->MergeFrom(
+      static_cast<const Expression_Literal_Map &>(from));
+}
+
+
+void Expression_Literal_Map::MergeFrom(const Expression_Literal_Map& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Map)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  key_values_.MergeFrom(from.key_values_);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_Literal_Map::CopyFrom(const Expression_Literal_Map& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Map)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_Literal_Map::IsInitialized() const {
+  return true;
+}
+
+void Expression_Literal_Map::InternalSwap(Expression_Literal_Map* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  key_values_.InternalSwap(&other->key_values_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[5]);
+}
+
+// ===================================================================
+
+class Expression_Literal_IntervalYearToMonth::_Internal {
+ public:
+};
+
+Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.IntervalYearToMonth)
+}
+Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(const Expression_Literal_IntervalYearToMonth& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&years_, &from.years_,
+    static_cast<size_t>(reinterpret_cast<char*>(&months_) -
+    reinterpret_cast<char*>(&years_)) + sizeof(months_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.IntervalYearToMonth)
+}
+
+inline void Expression_Literal_IntervalYearToMonth::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&years_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&months_) -
+    reinterpret_cast<char*>(&years_)) + sizeof(months_));
+}
+
+Expression_Literal_IntervalYearToMonth::~Expression_Literal_IntervalYearToMonth() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.Literal.IntervalYearToMonth)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_Literal_IntervalYearToMonth::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Expression_Literal_IntervalYearToMonth::ArenaDtor(void* object) {
+  Expression_Literal_IntervalYearToMonth* _this = reinterpret_cast< Expression_Literal_IntervalYearToMonth* >(object);
+  (void)_this;
+}
+void Expression_Literal_IntervalYearToMonth::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_Literal_IntervalYearToMonth::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_Literal_IntervalYearToMonth::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.IntervalYearToMonth)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&years_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&months_) -
+      reinterpret_cast<char*>(&years_)) + sizeof(months_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_Literal_IntervalYearToMonth::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 years = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          years_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 months = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          months_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_Literal_IntervalYearToMonth::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.IntervalYearToMonth)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 years = 1;
+  if (this->_internal_years() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_years(), target);
+  }
+
+  // int32 months = 2;
+  if (this->_internal_months() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_months(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.IntervalYearToMonth)
+  return target;
+}
+
+size_t Expression_Literal_IntervalYearToMonth::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.IntervalYearToMonth)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 years = 1;
+  if (this->_internal_years() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_years());
+  }
+
+  // int32 months = 2;
+  if (this->_internal_months() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_months());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_IntervalYearToMonth::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_Literal_IntervalYearToMonth::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_IntervalYearToMonth::GetClassData() const { return &_class_data_; }
+
+void Expression_Literal_IntervalYearToMonth::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_Literal_IntervalYearToMonth *>(to)->MergeFrom(
+      static_cast<const Expression_Literal_IntervalYearToMonth &>(from));
+}
+
+
+void Expression_Literal_IntervalYearToMonth::MergeFrom(const Expression_Literal_IntervalYearToMonth& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.IntervalYearToMonth)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_years() != 0) {
+    _internal_set_years(from._internal_years());
+  }
+  if (from._internal_months() != 0) {
+    _internal_set_months(from._internal_months());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_Literal_IntervalYearToMonth::CopyFrom(const Expression_Literal_IntervalYearToMonth& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.IntervalYearToMonth)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_Literal_IntervalYearToMonth::IsInitialized() const {
+  return true;
+}
+
+void Expression_Literal_IntervalYearToMonth::InternalSwap(Expression_Literal_IntervalYearToMonth* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalYearToMonth, months_)
+      + sizeof(Expression_Literal_IntervalYearToMonth::months_)
+      - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalYearToMonth, years_)>(
+          reinterpret_cast<char*>(&years_),
+          reinterpret_cast<char*>(&other->years_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalYearToMonth::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[6]);
+}
+
+// ===================================================================
+
+class Expression_Literal_IntervalDayToSecond::_Internal {
+ public:
+};
+
+Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.IntervalDayToSecond)
+}
+Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(const Expression_Literal_IntervalDayToSecond& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&days_, &from.days_,
+    static_cast<size_t>(reinterpret_cast<char*>(&seconds_) -
+    reinterpret_cast<char*>(&days_)) + sizeof(seconds_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.IntervalDayToSecond)
+}
+
+inline void Expression_Literal_IntervalDayToSecond::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&days_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&seconds_) -
+    reinterpret_cast<char*>(&days_)) + sizeof(seconds_));
+}
+
+Expression_Literal_IntervalDayToSecond::~Expression_Literal_IntervalDayToSecond() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.Literal.IntervalDayToSecond)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_Literal_IntervalDayToSecond::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Expression_Literal_IntervalDayToSecond::ArenaDtor(void* object) {
+  Expression_Literal_IntervalDayToSecond* _this = reinterpret_cast< Expression_Literal_IntervalDayToSecond* >(object);
+  (void)_this;
+}
+void Expression_Literal_IntervalDayToSecond::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_Literal_IntervalDayToSecond::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_Literal_IntervalDayToSecond::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.IntervalDayToSecond)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&days_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&seconds_) -
+      reinterpret_cast<char*>(&days_)) + sizeof(seconds_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_Literal_IntervalDayToSecond::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 days = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          days_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 seconds = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_Literal_IntervalDayToSecond::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.IntervalDayToSecond)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 days = 1;
+  if (this->_internal_days() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_days(), target);
+  }
+
+  // int32 seconds = 2;
+  if (this->_internal_seconds() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_seconds(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.IntervalDayToSecond)
+  return target;
+}
+
+size_t Expression_Literal_IntervalDayToSecond::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.IntervalDayToSecond)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 days = 1;
+  if (this->_internal_days() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_days());
+  }
+
+  // int32 seconds = 2;
+  if (this->_internal_seconds() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_seconds());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_IntervalDayToSecond::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_Literal_IntervalDayToSecond::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_IntervalDayToSecond::GetClassData() const { return &_class_data_; }
+
+void Expression_Literal_IntervalDayToSecond::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_Literal_IntervalDayToSecond *>(to)->MergeFrom(
+      static_cast<const Expression_Literal_IntervalDayToSecond &>(from));
+}
+
+
+void Expression_Literal_IntervalDayToSecond::MergeFrom(const Expression_Literal_IntervalDayToSecond& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.IntervalDayToSecond)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_days() != 0) {
+    _internal_set_days(from._internal_days());
+  }
+  if (from._internal_seconds() != 0) {
+    _internal_set_seconds(from._internal_seconds());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_Literal_IntervalDayToSecond::CopyFrom(const Expression_Literal_IntervalDayToSecond& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.IntervalDayToSecond)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_Literal_IntervalDayToSecond::IsInitialized() const {
+  return true;
+}
+
+void Expression_Literal_IntervalDayToSecond::InternalSwap(Expression_Literal_IntervalDayToSecond* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalDayToSecond, seconds_)
+      + sizeof(Expression_Literal_IntervalDayToSecond::seconds_)
+      - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalDayToSecond, days_)>(
+          reinterpret_cast<char*>(&days_),
+          reinterpret_cast<char*>(&other->days_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalDayToSecond::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[7]);
+}
+
+// ===================================================================
+
+class Expression_Literal_Struct::_Internal {
+ public:
+};
+
+Expression_Literal_Struct::Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  fields_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Struct)
+}
+Expression_Literal_Struct::Expression_Literal_Struct(const Expression_Literal_Struct& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      fields_(from.fields_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Struct)
+}
+
+inline void Expression_Literal_Struct::SharedCtor() {
+}
+
+Expression_Literal_Struct::~Expression_Literal_Struct() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Struct)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_Literal_Struct::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Expression_Literal_Struct::ArenaDtor(void* object) {
+  Expression_Literal_Struct* _this = reinterpret_cast< Expression_Literal_Struct* >(object);
+  (void)_this;
+}
+void Expression_Literal_Struct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_Literal_Struct::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_Literal_Struct::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Struct)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  fields_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_Literal_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Expression.Literal fields = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_fields(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_Literal_Struct::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Struct)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.Literal fields = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_fields_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_fields(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.Struct)
+  return target;
+}
+
+size_t Expression_Literal_Struct::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Struct)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.Literal fields = 1;
+  total_size += 1UL * this->_internal_fields_size();
+  for (const auto& msg : this->fields_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_Struct::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_Literal_Struct::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_Struct::GetClassData() const { return &_class_data_; }
+
+void Expression_Literal_Struct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_Literal_Struct *>(to)->MergeFrom(
+      static_cast<const Expression_Literal_Struct &>(from));
+}
+
+
+void Expression_Literal_Struct::MergeFrom(const Expression_Literal_Struct& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Struct)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  fields_.MergeFrom(from.fields_);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_Literal_Struct::CopyFrom(const Expression_Literal_Struct& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Struct)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_Literal_Struct::IsInitialized() const {
+  return true;
+}
+
+void Expression_Literal_Struct::InternalSwap(Expression_Literal_Struct* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  fields_.InternalSwap(&other->fields_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Struct::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[8]);
+}
+
+// ===================================================================
+
+class Expression_Literal_List::_Internal {
+ public:
+};
+
+Expression_Literal_List::Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  values_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.List)
+}
+Expression_Literal_List::Expression_Literal_List(const Expression_Literal_List& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      values_(from.values_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.List)
+}
+
+inline void Expression_Literal_List::SharedCtor() {
+}
+
+Expression_Literal_List::~Expression_Literal_List() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.Literal.List)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_Literal_List::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Expression_Literal_List::ArenaDtor(void* object) {
+  Expression_Literal_List* _this = reinterpret_cast< Expression_Literal_List* >(object);
+  (void)_this;
+}
+void Expression_Literal_List::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_Literal_List::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_Literal_List::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.List)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  values_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_Literal_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Expression.Literal values = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_values(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_Literal_List::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.List)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.Literal values = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_values_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_values(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.List)
+  return target;
+}
+
+size_t Expression_Literal_List::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.List)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.Literal values = 1;
+  total_size += 1UL * this->_internal_values_size();
+  for (const auto& msg : this->values_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_List::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_Literal_List::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_List::GetClassData() const { return &_class_data_; }
+
+void Expression_Literal_List::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_Literal_List *>(to)->MergeFrom(
+      static_cast<const Expression_Literal_List &>(from));
+}
+
+
+void Expression_Literal_List::MergeFrom(const Expression_Literal_List& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.List)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  values_.MergeFrom(from.values_);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_Literal_List::CopyFrom(const Expression_Literal_List& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.List)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_Literal_List::IsInitialized() const {
+  return true;
+}
+
+void Expression_Literal_List::InternalSwap(Expression_Literal_List* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  values_.InternalSwap(&other->values_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_List::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[9]);
+}
+
+// ===================================================================
+
+class Expression_Literal::_Internal {
+ public:
+  static const ::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month(const Expression_Literal* msg);
+  static const ::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second(const Expression_Literal* msg);
+  static const ::substrait::Expression_Literal_VarChar& var_char(const Expression_Literal* msg);
+  static const ::substrait::Expression_Literal_Decimal& decimal(const Expression_Literal* msg);
+  static const ::substrait::Expression_Literal_Struct& struct_(const Expression_Literal* msg);
+  static const ::substrait::Expression_Literal_Map& map(const Expression_Literal* msg);
+  static const ::substrait::Type& null(const Expression_Literal* msg);
+  static const ::substrait::Expression_Literal_List& list(const Expression_Literal* msg);
+  static const ::substrait::Type_List& empty_list(const Expression_Literal* msg);
+  static const ::substrait::Type_Map& empty_map(const Expression_Literal* msg);
+};
+
+const ::substrait::Expression_Literal_IntervalYearToMonth&
+Expression_Literal::_Internal::interval_year_to_month(const Expression_Literal* msg) {
+  return *msg->literal_type_.interval_year_to_month_;
+}
+const ::substrait::Expression_Literal_IntervalDayToSecond&
+Expression_Literal::_Internal::interval_day_to_second(const Expression_Literal* msg) {
+  return *msg->literal_type_.interval_day_to_second_;
+}
+const ::substrait::Expression_Literal_VarChar&
+Expression_Literal::_Internal::var_char(const Expression_Literal* msg) {
+  return *msg->literal_type_.var_char_;
+}
+const ::substrait::Expression_Literal_Decimal&
+Expression_Literal::_Internal::decimal(const Expression_Literal* msg) {
+  return *msg->literal_type_.decimal_;
+}
+const ::substrait::Expression_Literal_Struct&
+Expression_Literal::_Internal::struct_(const Expression_Literal* msg) {
+  return *msg->literal_type_.struct__;
+}
+const ::substrait::Expression_Literal_Map&
+Expression_Literal::_Internal::map(const Expression_Literal* msg) {
+  return *msg->literal_type_.map_;
+}
+const ::substrait::Type&
+Expression_Literal::_Internal::null(const Expression_Literal* msg) {
+  return *msg->literal_type_.null_;
+}
+const ::substrait::Expression_Literal_List&
+Expression_Literal::_Internal::list(const Expression_Literal* msg) {
+  return *msg->literal_type_.list_;
+}
+const ::substrait::Type_List&
+Expression_Literal::_Internal::empty_list(const Expression_Literal* msg) {
+  return *msg->literal_type_.empty_list_;
+}
+const ::substrait::Type_Map&
+Expression_Literal::_Internal::empty_map(const Expression_Literal* msg) {
+  return *msg->literal_type_.empty_map_;
+}
+void Expression_Literal::set_allocated_interval_year_to_month(::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_literal_type();
+  if (interval_year_to_month) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_IntervalYearToMonth>::GetOwningArena(interval_year_to_month);
+    if (message_arena != submessage_arena) {
+      interval_year_to_month = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, interval_year_to_month, submessage_arena);
+    }
+    set_has_interval_year_to_month();
+    literal_type_.interval_year_to_month_ = interval_year_to_month;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.interval_year_to_month)
+}
+void Expression_Literal::set_allocated_interval_day_to_second(::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_literal_type();
+  if (interval_day_to_second) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_IntervalDayToSecond>::GetOwningArena(interval_day_to_second);
+    if (message_arena != submessage_arena) {
+      interval_day_to_second = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, interval_day_to_second, submessage_arena);
+    }
+    set_has_interval_day_to_second();
+    literal_type_.interval_day_to_second_ = interval_day_to_second;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.interval_day_to_second)
+}
+void Expression_Literal::set_allocated_var_char(::substrait::Expression_Literal_VarChar* var_char) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_literal_type();
+  if (var_char) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_VarChar>::GetOwningArena(var_char);
+    if (message_arena != submessage_arena) {
+      var_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, var_char, submessage_arena);
+    }
+    set_has_var_char();
+    literal_type_.var_char_ = var_char;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.var_char)
+}
+void Expression_Literal::set_allocated_decimal(::substrait::Expression_Literal_Decimal* decimal) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_literal_type();
+  if (decimal) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_Decimal>::GetOwningArena(decimal);
+    if (message_arena != submessage_arena) {
+      decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, decimal, submessage_arena);
+    }
+    set_has_decimal();
+    literal_type_.decimal_ = decimal;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.decimal)
+}
+void Expression_Literal::set_allocated_struct_(::substrait::Expression_Literal_Struct* struct_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_literal_type();
+  if (struct_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_Struct>::GetOwningArena(struct_);
+    if (message_arena != submessage_arena) {
+      struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, struct_, submessage_arena);
+    }
+    set_has_struct_();
+    literal_type_.struct__ = struct_;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.struct)
+}
+void Expression_Literal::set_allocated_map(::substrait::Expression_Literal_Map* map) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_literal_type();
+  if (map) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_Map>::GetOwningArena(map);
+    if (message_arena != submessage_arena) {
+      map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, map, submessage_arena);
+    }
+    set_has_map();
+    literal_type_.map_ = map;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.map)
+}
+void Expression_Literal::set_allocated_null(::substrait::Type* null) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_literal_type();
+  if (null) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(null));
+    if (message_arena != submessage_arena) {
+      null = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, null, submessage_arena);
+    }
+    set_has_null();
+    literal_type_.null_ = null;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.null)
+}
+void Expression_Literal::clear_null() {
+  if (_internal_has_null()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete literal_type_.null_;
+    }
+    clear_has_literal_type();
+  }
+}
+void Expression_Literal::set_allocated_list(::substrait::Expression_Literal_List* list) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_literal_type();
+  if (list) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_List>::GetOwningArena(list);
+    if (message_arena != submessage_arena) {
+      list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, list, submessage_arena);
+    }
+    set_has_list();
+    literal_type_.list_ = list;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.list)
+}
+void Expression_Literal::set_allocated_empty_list(::substrait::Type_List* empty_list) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_literal_type();
+  if (empty_list) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_list));
+    if (message_arena != submessage_arena) {
+      empty_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, empty_list, submessage_arena);
+    }
+    set_has_empty_list();
+    literal_type_.empty_list_ = empty_list;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.empty_list)
+}
+void Expression_Literal::clear_empty_list() {
+  if (_internal_has_empty_list()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete literal_type_.empty_list_;
+    }
+    clear_has_literal_type();
+  }
+}
+void Expression_Literal::set_allocated_empty_map(::substrait::Type_Map* empty_map) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_literal_type();
+  if (empty_map) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_map));
+    if (message_arena != submessage_arena) {
+      empty_map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, empty_map, submessage_arena);
+    }
+    set_has_empty_map();
+    literal_type_.empty_map_ = empty_map;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.empty_map)
+}
+void Expression_Literal::clear_empty_map() {
+  if (_internal_has_empty_map()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete literal_type_.empty_map_;
+    }
+    clear_has_literal_type();
+  }
+}
+Expression_Literal::Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal)
+}
+Expression_Literal::Expression_Literal(const Expression_Literal& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  nullable_ = from.nullable_;
+  clear_has_literal_type();
+  switch (from.literal_type_case()) {
+    case kBoolean: {
+      _internal_set_boolean(from._internal_boolean());
+      break;
+    }
+    case kI8: {
+      _internal_set_i8(from._internal_i8());
+      break;
+    }
+    case kI16: {
+      _internal_set_i16(from._internal_i16());
+      break;
+    }
+    case kI32: {
+      _internal_set_i32(from._internal_i32());
+      break;
+    }
+    case kI64: {
+      _internal_set_i64(from._internal_i64());
+      break;
+    }
+    case kFp32: {
+      _internal_set_fp32(from._internal_fp32());
+      break;
+    }
+    case kFp64: {
+      _internal_set_fp64(from._internal_fp64());
+      break;
+    }
+    case kString: {
+      _internal_set_string(from._internal_string());
+      break;
+    }
+    case kBinary: {
+      _internal_set_binary(from._internal_binary());
+      break;
+    }
+    case kTimestamp: {
+      _internal_set_timestamp(from._internal_timestamp());
+      break;
+    }
+    case kDate: {
+      _internal_set_date(from._internal_date());
+      break;
+    }
+    case kTime: {
+      _internal_set_time(from._internal_time());
+      break;
+    }
+    case kIntervalYearToMonth: {
+      _internal_mutable_interval_year_to_month()->::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month());
+      break;
+    }
+    case kIntervalDayToSecond: {
+      _internal_mutable_interval_day_to_second()->::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second());
+      break;
+    }
+    case kFixedChar: {
+      _internal_set_fixed_char(from._internal_fixed_char());
+      break;
+    }
+    case kVarChar: {
+      _internal_mutable_var_char()->::substrait::Expression_Literal_VarChar::MergeFrom(from._internal_var_char());
+      break;
+    }
+    case kFixedBinary: {
+      _internal_set_fixed_binary(from._internal_fixed_binary());
+      break;
+    }
+    case kDecimal: {
+      _internal_mutable_decimal()->::substrait::Expression_Literal_Decimal::MergeFrom(from._internal_decimal());
+      break;
+    }
+    case kStruct: {
+      _internal_mutable_struct_()->::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_());
+      break;
+    }
+    case kMap: {
+      _internal_mutable_map()->::substrait::Expression_Literal_Map::MergeFrom(from._internal_map());
+      break;
+    }
+    case kTimestampTz: {
+      _internal_set_timestamp_tz(from._internal_timestamp_tz());
+      break;
+    }
+    case kUuid: {
+      _internal_set_uuid(from._internal_uuid());
+      break;
+    }
+    case kNull: {
+      _internal_mutable_null()->::substrait::Type::MergeFrom(from._internal_null());
+      break;
+    }
+    case kList: {
+      _internal_mutable_list()->::substrait::Expression_Literal_List::MergeFrom(from._internal_list());
+      break;
+    }
+    case kEmptyList: {
+      _internal_mutable_empty_list()->::substrait::Type_List::MergeFrom(from._internal_empty_list());
+      break;
+    }
+    case kEmptyMap: {
+      _internal_mutable_empty_map()->::substrait::Type_Map::MergeFrom(from._internal_empty_map());
+      break;
+    }
+    case LITERAL_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal)
+}
+
+inline void Expression_Literal::SharedCtor() {
+nullable_ = false;
+clear_has_literal_type();
+}
+
+Expression_Literal::~Expression_Literal() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.Literal)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_Literal::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_literal_type()) {
+    clear_literal_type();
+  }
+}
+
+void Expression_Literal::ArenaDtor(void* object) {
+  Expression_Literal* _this = reinterpret_cast< Expression_Literal* >(object);
+  (void)_this;
+}
+void Expression_Literal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_Literal::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_Literal::clear_literal_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.Literal)
+  switch (literal_type_case()) {
+    case kBoolean: {
+      // No need to clear
+      break;
+    }
+    case kI8: {
+      // No need to clear
+      break;
+    }
+    case kI16: {
+      // No need to clear
+      break;
+    }
+    case kI32: {
+      // No need to clear
+      break;
+    }
+    case kI64: {
+      // No need to clear
+      break;
+    }
+    case kFp32: {
+      // No need to clear
+      break;
+    }
+    case kFp64: {
+      // No need to clear
+      break;
+    }
+    case kString: {
+      literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+      break;
+    }
+    case kBinary: {
+      literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+      break;
+    }
+    case kTimestamp: {
+      // No need to clear
+      break;
+    }
+    case kDate: {
+      // No need to clear
+      break;
+    }
+    case kTime: {
+      // No need to clear
+      break;
+    }
+    case kIntervalYearToMonth: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete literal_type_.interval_year_to_month_;
+      }
+      break;
+    }
+    case kIntervalDayToSecond: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete literal_type_.interval_day_to_second_;
+      }
+      break;
+    }
+    case kFixedChar: {
+      literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+      break;
+    }
+    case kVarChar: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete literal_type_.var_char_;
+      }
+      break;
+    }
+    case kFixedBinary: {
+      literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+      break;
+    }
+    case kDecimal: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete literal_type_.decimal_;
+      }
+      break;
+    }
+    case kStruct: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete literal_type_.struct__;
+      }
+      break;
+    }
+    case kMap: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete literal_type_.map_;
+      }
+      break;
+    }
+    case kTimestampTz: {
+      // No need to clear
+      break;
+    }
+    case kUuid: {
+      literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+      break;
+    }
+    case kNull: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete literal_type_.null_;
+      }
+      break;
+    }
+    case kList: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete literal_type_.list_;
+      }
+      break;
+    }
+    case kEmptyList: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete literal_type_.empty_list_;
+      }
+      break;
+    }
+    case kEmptyMap: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete literal_type_.empty_map_;
+      }
+      break;
+    }
+    case LITERAL_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = LITERAL_TYPE_NOT_SET;
+}
+
+
+void Expression_Literal::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  nullable_ = false;
+  clear_literal_type();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // bool boolean = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _internal_set_boolean(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 i8 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          _internal_set_i8(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 i16 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _internal_set_i16(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 i32 = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          _internal_set_i32(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int64 i64 = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          _internal_set_i64(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // float fp32 = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 85)) {
+          _internal_set_fp32(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+          ptr += sizeof(float);
+        } else
+          goto handle_unusual;
+        continue;
+      // double fp64 = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 89)) {
+          _internal_set_fp64(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // string string = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          auto str = _internal_mutable_string();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.string"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bytes binary = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          auto str = _internal_mutable_binary();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int64 timestamp = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
+          _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 date = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
+          _internal_set_date(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int64 time = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 136)) {
+          _internal_set_time(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          ptr = ctx->ParseMessage(_internal_mutable_interval_year_to_month(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
+          ptr = ctx->ParseMessage(_internal_mutable_interval_day_to_second(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string fixed_char = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
+          auto str = _internal_mutable_fixed_char();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.fixed_char"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.Literal.VarChar var_char = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
+          ptr = ctx->ParseMessage(_internal_mutable_var_char(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bytes fixed_binary = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
+          auto str = _internal_mutable_fixed_binary();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.Literal.Decimal decimal = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 194)) {
+          ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.Literal.Struct struct = 25;
+      case 25:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 202)) {
+          ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.Literal.Map map = 26;
+      case 26:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 210)) {
+          ptr = ctx->ParseMessage(_internal_mutable_map(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int64 timestamp_tz = 27;
+      case 27:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 216)) {
+          _internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bytes uuid = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 226)) {
+          auto str = _internal_mutable_uuid();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type null = 29;
+      case 29:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 234)) {
+          ptr = ctx->ParseMessage(_internal_mutable_null(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.Literal.List list = 30;
+      case 30:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 242)) {
+          ptr = ctx->ParseMessage(_internal_mutable_list(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.List empty_list = 31;
+      case 31:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 250)) {
+          ptr = ctx->ParseMessage(_internal_mutable_empty_list(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Map empty_map = 32;
+      case 32:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 2)) {
+          ptr = ctx->ParseMessage(_internal_mutable_empty_map(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool nullable = 50;
+      case 50:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
+          nullable_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_Literal::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bool boolean = 1;
+  if (_internal_has_boolean()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_boolean(), target);
+  }
+
+  // int32 i8 = 2;
+  if (_internal_has_i8()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_i8(), target);
+  }
+
+  // int32 i16 = 3;
+  if (_internal_has_i16()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_i16(), target);
+  }
+
+  // int32 i32 = 5;
+  if (_internal_has_i32()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_i32(), target);
+  }
+
+  // int64 i64 = 7;
+  if (_internal_has_i64()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->_internal_i64(), target);
+  }
+
+  // float fp32 = 10;
+  if (_internal_has_fp32()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_fp32(), target);
+  }
+
+  // double fp64 = 11;
+  if (_internal_has_fp64()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(11, this->_internal_fp64(), target);
+  }
+
+  // string string = 12;
+  if (_internal_has_string()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_string().data(), static_cast<int>(this->_internal_string().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Expression.Literal.string");
+    target = stream->WriteStringMaybeAliased(
+        12, this->_internal_string(), target);
+  }
+
+  // bytes binary = 13;
+  if (_internal_has_binary()) {
+    target = stream->WriteBytesMaybeAliased(
+        13, this->_internal_binary(), target);
+  }
+
+  // int64 timestamp = 14;
+  if (_internal_has_timestamp()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(14, this->_internal_timestamp(), target);
+  }
+
+  // int32 date = 16;
+  if (_internal_has_date()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(16, this->_internal_date(), target);
+  }
+
+  // int64 time = 17;
+  if (_internal_has_time()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(17, this->_internal_time(), target);
+  }
+
+  // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19;
+  if (_internal_has_interval_year_to_month()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        19, _Internal::interval_year_to_month(this), target, stream);
+  }
+
+  // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20;
+  if (_internal_has_interval_day_to_second()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        20, _Internal::interval_day_to_second(this), target, stream);
+  }
+
+  // string fixed_char = 21;
+  if (_internal_has_fixed_char()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_fixed_char().data(), static_cast<int>(this->_internal_fixed_char().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Expression.Literal.fixed_char");
+    target = stream->WriteStringMaybeAliased(
+        21, this->_internal_fixed_char(), target);
+  }
+
+  // .substrait.Expression.Literal.VarChar var_char = 22;
+  if (_internal_has_var_char()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        22, _Internal::var_char(this), target, stream);
+  }
+
+  // bytes fixed_binary = 23;
+  if (_internal_has_fixed_binary()) {
+    target = stream->WriteBytesMaybeAliased(
+        23, this->_internal_fixed_binary(), target);
+  }
+
+  // .substrait.Expression.Literal.Decimal decimal = 24;
+  if (_internal_has_decimal()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        24, _Internal::decimal(this), target, stream);
+  }
+
+  // .substrait.Expression.Literal.Struct struct = 25;
+  if (_internal_has_struct_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        25, _Internal::struct_(this), target, stream);
+  }
+
+  // .substrait.Expression.Literal.Map map = 26;
+  if (_internal_has_map()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        26, _Internal::map(this), target, stream);
+  }
+
+  // int64 timestamp_tz = 27;
+  if (_internal_has_timestamp_tz()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(27, this->_internal_timestamp_tz(), target);
+  }
+
+  // bytes uuid = 28;
+  if (_internal_has_uuid()) {
+    target = stream->WriteBytesMaybeAliased(
+        28, this->_internal_uuid(), target);
+  }
+
+  // .substrait.Type null = 29;
+  if (_internal_has_null()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        29, _Internal::null(this), target, stream);
+  }
+
+  // .substrait.Expression.Literal.List list = 30;
+  if (_internal_has_list()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        30, _Internal::list(this), target, stream);
+  }
+
+  // .substrait.Type.List empty_list = 31;
+  if (_internal_has_empty_list()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        31, _Internal::empty_list(this), target, stream);
+  }
+
+  // .substrait.Type.Map empty_map = 32;
+  if (_internal_has_empty_map()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        32, _Internal::empty_map(this), target, stream);
+  }
+
+  // bool nullable = 50;
+  if (this->_internal_nullable() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(50, this->_internal_nullable(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal)
+  return target;
+}
+
+size_t Expression_Literal::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // bool nullable = 50;
+  if (this->_internal_nullable() != 0) {
+    total_size += 2 + 1;
+  }
+
+  switch (literal_type_case()) {
+    // bool boolean = 1;
+    case kBoolean: {
+      total_size += 1 + 1;
+      break;
+    }
+    // int32 i8 = 2;
+    case kI8: {
+      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_i8());
+      break;
+    }
+    // int32 i16 = 3;
+    case kI16: {
+      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_i16());
+      break;
+    }
+    // int32 i32 = 5;
+    case kI32: {
+      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_i32());
+      break;
+    }
+    // int64 i64 = 7;
+    case kI64: {
+      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_i64());
+      break;
+    }
+    // float fp32 = 10;
+    case kFp32: {
+      total_size += 1 + 4;
+      break;
+    }
+    // double fp64 = 11;
+    case kFp64: {
+      total_size += 1 + 8;
+      break;
+    }
+    // string string = 12;
+    case kString: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_string());
+      break;
+    }
+    // bytes binary = 13;
+    case kBinary: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_binary());
+      break;
+    }
+    // int64 timestamp = 14;
+    case kTimestamp: {
+      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp());
+      break;
+    }
+    // int32 date = 16;
+    case kDate: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_date());
+      break;
+    }
+    // int64 time = 17;
+    case kTime: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
+          this->_internal_time());
+      break;
+    }
+    // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19;
+    case kIntervalYearToMonth: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *literal_type_.interval_year_to_month_);
+      break;
+    }
+    // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20;
+    case kIntervalDayToSecond: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *literal_type_.interval_day_to_second_);
+      break;
+    }
+    // string fixed_char = 21;
+    case kFixedChar: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_fixed_char());
+      break;
+    }
+    // .substrait.Expression.Literal.VarChar var_char = 22;
+    case kVarChar: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *literal_type_.var_char_);
+      break;
+    }
+    // bytes fixed_binary = 23;
+    case kFixedBinary: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_fixed_binary());
+      break;
+    }
+    // .substrait.Expression.Literal.Decimal decimal = 24;
+    case kDecimal: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *literal_type_.decimal_);
+      break;
+    }
+    // .substrait.Expression.Literal.Struct struct = 25;
+    case kStruct: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *literal_type_.struct__);
+      break;
+    }
+    // .substrait.Expression.Literal.Map map = 26;
+    case kMap: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *literal_type_.map_);
+      break;
+    }
+    // int64 timestamp_tz = 27;
+    case kTimestampTz: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
+          this->_internal_timestamp_tz());
+      break;
+    }
+    // bytes uuid = 28;
+    case kUuid: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+          this->_internal_uuid());
+      break;
+    }
+    // .substrait.Type null = 29;
+    case kNull: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *literal_type_.null_);
+      break;
+    }
+    // .substrait.Expression.Literal.List list = 30;
+    case kList: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *literal_type_.list_);
+      break;
+    }
+    // .substrait.Type.List empty_list = 31;
+    case kEmptyList: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *literal_type_.empty_list_);
+      break;
+    }
+    // .substrait.Type.Map empty_map = 32;
+    case kEmptyMap: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *literal_type_.empty_map_);
+      break;
+    }
+    case LITERAL_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_Literal::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal::GetClassData() const { return &_class_data_; }
+
+void Expression_Literal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_Literal *>(to)->MergeFrom(
+      static_cast<const Expression_Literal &>(from));
+}
+
+
+void Expression_Literal::MergeFrom(const Expression_Literal& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_nullable() != 0) {
+    _internal_set_nullable(from._internal_nullable());
+  }
+  switch (from.literal_type_case()) {
+    case kBoolean: {
+      _internal_set_boolean(from._internal_boolean());
+      break;
+    }
+    case kI8: {
+      _internal_set_i8(from._internal_i8());
+      break;
+    }
+    case kI16: {
+      _internal_set_i16(from._internal_i16());
+      break;
+    }
+    case kI32: {
+      _internal_set_i32(from._internal_i32());
+      break;
+    }
+    case kI64: {
+      _internal_set_i64(from._internal_i64());
+      break;
+    }
+    case kFp32: {
+      _internal_set_fp32(from._internal_fp32());
+      break;
+    }
+    case kFp64: {
+      _internal_set_fp64(from._internal_fp64());
+      break;
+    }
+    case kString: {
+      _internal_set_string(from._internal_string());
+      break;
+    }
+    case kBinary: {
+      _internal_set_binary(from._internal_binary());
+      break;
+    }
+    case kTimestamp: {
+      _internal_set_timestamp(from._internal_timestamp());
+      break;
+    }
+    case kDate: {
+      _internal_set_date(from._internal_date());
+      break;
+    }
+    case kTime: {
+      _internal_set_time(from._internal_time());
+      break;
+    }
+    case kIntervalYearToMonth: {
+      _internal_mutable_interval_year_to_month()->::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month());
+      break;
+    }
+    case kIntervalDayToSecond: {
+      _internal_mutable_interval_day_to_second()->::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second());
+      break;
+    }
+    case kFixedChar: {
+      _internal_set_fixed_char(from._internal_fixed_char());
+      break;
+    }
+    case kVarChar: {
+      _internal_mutable_var_char()->::substrait::Expression_Literal_VarChar::MergeFrom(from._internal_var_char());
+      break;
+    }
+    case kFixedBinary: {
+      _internal_set_fixed_binary(from._internal_fixed_binary());
+      break;
+    }
+    case kDecimal: {
+      _internal_mutable_decimal()->::substrait::Expression_Literal_Decimal::MergeFrom(from._internal_decimal());
+      break;
+    }
+    case kStruct: {
+      _internal_mutable_struct_()->::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_());
+      break;
+    }
+    case kMap: {
+      _internal_mutable_map()->::substrait::Expression_Literal_Map::MergeFrom(from._internal_map());
+      break;
+    }
+    case kTimestampTz: {
+      _internal_set_timestamp_tz(from._internal_timestamp_tz());
+      break;
+    }
+    case kUuid: {
+      _internal_set_uuid(from._internal_uuid());
+      break;
+    }
+    case kNull: {
+      _internal_mutable_null()->::substrait::Type::MergeFrom(from._internal_null());
+      break;
+    }
+    case kList: {
+      _internal_mutable_list()->::substrait::Expression_Literal_List::MergeFrom(from._internal_list());
+      break;
+    }
+    case kEmptyList: {
+      _internal_mutable_empty_list()->::substrait::Type_List::MergeFrom(from._internal_empty_list());
+      break;
+    }
+    case kEmptyMap: {
+      _internal_mutable_empty_map()->::substrait::Type_Map::MergeFrom(from._internal_empty_map());
+      break;
+    }
+    case LITERAL_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_Literal::CopyFrom(const Expression_Literal& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_Literal::IsInitialized() const {
+  return true;
+}
+
+void Expression_Literal::InternalSwap(Expression_Literal* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(nullable_, other->nullable_);
+  swap(literal_type_, other->literal_type_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[10]);
+}
+
+// ===================================================================
+
+class Expression_ScalarFunction::_Internal {
+ public:
+  static const ::substrait::Type& output_type(const Expression_ScalarFunction* msg);
+};
+
+const ::substrait::Type&
+Expression_ScalarFunction::_Internal::output_type(const Expression_ScalarFunction* msg) {
+  return *msg->output_type_;
+}
+void Expression_ScalarFunction::clear_output_type() {
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+}
+Expression_ScalarFunction::Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  args_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.ScalarFunction)
+}
+Expression_ScalarFunction::Expression_ScalarFunction(const Expression_ScalarFunction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      args_(from.args_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_output_type()) {
+    output_type_ = new ::substrait::Type(*from.output_type_);
+  } else {
+    output_type_ = nullptr;
+  }
+  function_reference_ = from.function_reference_;
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.ScalarFunction)
+}
+
+inline void Expression_ScalarFunction::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&output_type_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&function_reference_) -
+    reinterpret_cast<char*>(&output_type_)) + sizeof(function_reference_));
+}
+
+Expression_ScalarFunction::~Expression_ScalarFunction() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.ScalarFunction)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_ScalarFunction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete output_type_;
+}
+
+void Expression_ScalarFunction::ArenaDtor(void* object) {
+  Expression_ScalarFunction* _this = reinterpret_cast< Expression_ScalarFunction* >(object);
+  (void)_this;
+}
+void Expression_ScalarFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_ScalarFunction::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_ScalarFunction::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.ScalarFunction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  args_.Clear();
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+  function_reference_ = 0u;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_ScalarFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 function_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.Expression args = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_args(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type output_type = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_ScalarFunction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ScalarFunction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 function_reference = 1;
+  if (this->_internal_function_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target);
+  }
+
+  // repeated .substrait.Expression args = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_args_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_args(i), target, stream);
+  }
+
+  // .substrait.Type output_type = 3;
+  if (this->_internal_has_output_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::output_type(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ScalarFunction)
+  return target;
+}
+
+size_t Expression_ScalarFunction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ScalarFunction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression args = 2;
+  total_size += 1UL * this->_internal_args_size();
+  for (const auto& msg : this->args_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.Type output_type = 3;
+  if (this->_internal_has_output_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *output_type_);
+  }
+
+  // uint32 function_reference = 1;
+  if (this->_internal_function_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_reference());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ScalarFunction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_ScalarFunction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ScalarFunction::GetClassData() const { return &_class_data_; }
+
+void Expression_ScalarFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_ScalarFunction *>(to)->MergeFrom(
+      static_cast<const Expression_ScalarFunction &>(from));
+}
+
+
+void Expression_ScalarFunction::MergeFrom(const Expression_ScalarFunction& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ScalarFunction)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  args_.MergeFrom(from.args_);
+  if (from._internal_has_output_type()) {
+    _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type());
+  }
+  if (from._internal_function_reference() != 0) {
+    _internal_set_function_reference(from._internal_function_reference());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_ScalarFunction::CopyFrom(const Expression_ScalarFunction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ScalarFunction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_ScalarFunction::IsInitialized() const {
+  return true;
+}
+
+void Expression_ScalarFunction::InternalSwap(Expression_ScalarFunction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  args_.InternalSwap(&other->args_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_ScalarFunction, function_reference_)
+      + sizeof(Expression_ScalarFunction::function_reference_)
+      - PROTOBUF_FIELD_OFFSET(Expression_ScalarFunction, output_type_)>(
+          reinterpret_cast<char*>(&output_type_),
+          reinterpret_cast<char*>(&other->output_type_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_ScalarFunction::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[11]);
+}
+
+// ===================================================================
+
+class Expression_WindowFunction_Bound_Preceding::_Internal {
+ public:
+};
+
+Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Preceding)
+}
+Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(const Expression_WindowFunction_Bound_Preceding& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  offset_ = from.offset_;
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Preceding)
+}
+
+inline void Expression_WindowFunction_Bound_Preceding::SharedCtor() {
+offset_ = int64_t{0};
+}
+
+Expression_WindowFunction_Bound_Preceding::~Expression_WindowFunction_Bound_Preceding() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound.Preceding)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_WindowFunction_Bound_Preceding::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Expression_WindowFunction_Bound_Preceding::ArenaDtor(void* object) {
+  Expression_WindowFunction_Bound_Preceding* _this = reinterpret_cast< Expression_WindowFunction_Bound_Preceding* >(object);
+  (void)_this;
+}
+void Expression_WindowFunction_Bound_Preceding::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_WindowFunction_Bound_Preceding::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_WindowFunction_Bound_Preceding::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.Preceding)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  offset_ = int64_t{0};
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_WindowFunction_Bound_Preceding::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int64 offset = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_WindowFunction_Bound_Preceding::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.Preceding)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int64 offset = 1;
+  if (this->_internal_offset() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_offset(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound.Preceding)
+  return target;
+}
+
+size_t Expression_WindowFunction_Bound_Preceding::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.Preceding)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int64 offset = 1;
+  if (this->_internal_offset() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_Preceding::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_WindowFunction_Bound_Preceding::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_Preceding::GetClassData() const { return &_class_data_; }
+
+void Expression_WindowFunction_Bound_Preceding::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_WindowFunction_Bound_Preceding *>(to)->MergeFrom(
+      static_cast<const Expression_WindowFunction_Bound_Preceding &>(from));
+}
+
+
+void Expression_WindowFunction_Bound_Preceding::MergeFrom(const Expression_WindowFunction_Bound_Preceding& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.Preceding)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_offset() != 0) {
+    _internal_set_offset(from._internal_offset());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_WindowFunction_Bound_Preceding::CopyFrom(const Expression_WindowFunction_Bound_Preceding& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound.Preceding)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_WindowFunction_Bound_Preceding::IsInitialized() const {
+  return true;
+}
+
+void Expression_WindowFunction_Bound_Preceding::InternalSwap(Expression_WindowFunction_Bound_Preceding* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(offset_, other->offset_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Preceding::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[12]);
+}
+
+// ===================================================================
+
+class Expression_WindowFunction_Bound_Following::_Internal {
+ public:
+};
+
+Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Following)
+}
+Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(const Expression_WindowFunction_Bound_Following& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  offset_ = from.offset_;
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Following)
+}
+
+inline void Expression_WindowFunction_Bound_Following::SharedCtor() {
+offset_ = int64_t{0};
+}
+
+Expression_WindowFunction_Bound_Following::~Expression_WindowFunction_Bound_Following() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound.Following)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_WindowFunction_Bound_Following::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Expression_WindowFunction_Bound_Following::ArenaDtor(void* object) {
+  Expression_WindowFunction_Bound_Following* _this = reinterpret_cast< Expression_WindowFunction_Bound_Following* >(object);
+  (void)_this;
+}
+void Expression_WindowFunction_Bound_Following::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_WindowFunction_Bound_Following::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_WindowFunction_Bound_Following::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.Following)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  offset_ = int64_t{0};
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_WindowFunction_Bound_Following::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int64 offset = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_WindowFunction_Bound_Following::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.Following)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int64 offset = 1;
+  if (this->_internal_offset() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_offset(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound.Following)
+  return target;
+}
+
+size_t Expression_WindowFunction_Bound_Following::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.Following)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int64 offset = 1;
+  if (this->_internal_offset() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_Following::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_WindowFunction_Bound_Following::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_Following::GetClassData() const { return &_class_data_; }
+
+void Expression_WindowFunction_Bound_Following::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_WindowFunction_Bound_Following *>(to)->MergeFrom(
+      static_cast<const Expression_WindowFunction_Bound_Following &>(from));
+}
+
+
+void Expression_WindowFunction_Bound_Following::MergeFrom(const Expression_WindowFunction_Bound_Following& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.Following)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_offset() != 0) {
+    _internal_set_offset(from._internal_offset());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_WindowFunction_Bound_Following::CopyFrom(const Expression_WindowFunction_Bound_Following& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound.Following)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_WindowFunction_Bound_Following::IsInitialized() const {
+  return true;
+}
+
+void Expression_WindowFunction_Bound_Following::InternalSwap(Expression_WindowFunction_Bound_Following* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(offset_, other->offset_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Following::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[13]);
+}
+
+// ===================================================================
+
+class Expression_WindowFunction_Bound_CurrentRow::_Internal {
+ public:
+};
+
+Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.CurrentRow)
+}
+Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(const Expression_WindowFunction_Bound_CurrentRow& from)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.CurrentRow)
+}
+
+
+
+
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_CurrentRow::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_CurrentRow::GetClassData() const { return &_class_data_; }
+
+
+
+
+
+
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_CurrentRow::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[14]);
+}
+
+// ===================================================================
+
+class Expression_WindowFunction_Bound_Unbounded::_Internal {
+ public:
+};
+
+Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Unbounded)
+}
+Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(const Expression_WindowFunction_Bound_Unbounded& from)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Unbounded)
+}
+
+
+
+
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_Unbounded::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_Unbounded::GetClassData() const { return &_class_data_; }
+
+
+
+
+
+
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Unbounded::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[15]);
+}
+
+// ===================================================================
+
+class Expression_WindowFunction_Bound::_Internal {
+ public:
+  static const ::substrait::Expression_WindowFunction_Bound_Preceding& preceding(const Expression_WindowFunction_Bound* msg);
+  static const ::substrait::Expression_WindowFunction_Bound_Following& following(const Expression_WindowFunction_Bound* msg);
+  static const ::substrait::Expression_WindowFunction_Bound_CurrentRow& current_row(const Expression_WindowFunction_Bound* msg);
+  static const ::substrait::Expression_WindowFunction_Bound_Unbounded& unbounded(const Expression_WindowFunction_Bound* msg);
+};
+
+const ::substrait::Expression_WindowFunction_Bound_Preceding&
+Expression_WindowFunction_Bound::_Internal::preceding(const Expression_WindowFunction_Bound* msg) {
+  return *msg->kind_.preceding_;
+}
+const ::substrait::Expression_WindowFunction_Bound_Following&
+Expression_WindowFunction_Bound::_Internal::following(const Expression_WindowFunction_Bound* msg) {
+  return *msg->kind_.following_;
+}
+const ::substrait::Expression_WindowFunction_Bound_CurrentRow&
+Expression_WindowFunction_Bound::_Internal::current_row(const Expression_WindowFunction_Bound* msg) {
+  return *msg->kind_.current_row_;
+}
+const ::substrait::Expression_WindowFunction_Bound_Unbounded&
+Expression_WindowFunction_Bound::_Internal::unbounded(const Expression_WindowFunction_Bound* msg) {
+  return *msg->kind_.unbounded_;
+}
+void Expression_WindowFunction_Bound::set_allocated_preceding(::substrait::Expression_WindowFunction_Bound_Preceding* preceding) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (preceding) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_Preceding>::GetOwningArena(preceding);
+    if (message_arena != submessage_arena) {
+      preceding = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, preceding, submessage_arena);
+    }
+    set_has_preceding();
+    kind_.preceding_ = preceding;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.preceding)
+}
+void Expression_WindowFunction_Bound::set_allocated_following(::substrait::Expression_WindowFunction_Bound_Following* following) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (following) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_Following>::GetOwningArena(following);
+    if (message_arena != submessage_arena) {
+      following = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, following, submessage_arena);
+    }
+    set_has_following();
+    kind_.following_ = following;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.following)
+}
+void Expression_WindowFunction_Bound::set_allocated_current_row(::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (current_row) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_CurrentRow>::GetOwningArena(current_row);
+    if (message_arena != submessage_arena) {
+      current_row = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, current_row, submessage_arena);
+    }
+    set_has_current_row();
+    kind_.current_row_ = current_row;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.current_row)
+}
+void Expression_WindowFunction_Bound::set_allocated_unbounded(::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (unbounded) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_Unbounded>::GetOwningArena(unbounded);
+    if (message_arena != submessage_arena) {
+      unbounded = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, unbounded, submessage_arena);
+    }
+    set_has_unbounded();
+    kind_.unbounded_ = unbounded;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.unbounded)
+}
+Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound)
+}
+Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(const Expression_WindowFunction_Bound& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_kind();
+  switch (from.kind_case()) {
+    case kPreceding: {
+      _internal_mutable_preceding()->::substrait::Expression_WindowFunction_Bound_Preceding::MergeFrom(from._internal_preceding());
+      break;
+    }
+    case kFollowing: {
+      _internal_mutable_following()->::substrait::Expression_WindowFunction_Bound_Following::MergeFrom(from._internal_following());
+      break;
+    }
+    case kCurrentRow: {
+      _internal_mutable_current_row()->::substrait::Expression_WindowFunction_Bound_CurrentRow::MergeFrom(from._internal_current_row());
+      break;
+    }
+    case kUnbounded: {
+      _internal_mutable_unbounded()->::substrait::Expression_WindowFunction_Bound_Unbounded::MergeFrom(from._internal_unbounded());
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound)
+}
+
+inline void Expression_WindowFunction_Bound::SharedCtor() {
+clear_has_kind();
+}
+
+Expression_WindowFunction_Bound::~Expression_WindowFunction_Bound() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_WindowFunction_Bound::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_kind()) {
+    clear_kind();
+  }
+}
+
+void Expression_WindowFunction_Bound::ArenaDtor(void* object) {
+  Expression_WindowFunction_Bound* _this = reinterpret_cast< Expression_WindowFunction_Bound* >(object);
+  (void)_this;
+}
+void Expression_WindowFunction_Bound::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_WindowFunction_Bound::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_WindowFunction_Bound::clear_kind() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.WindowFunction.Bound)
+  switch (kind_case()) {
+    case kPreceding: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.preceding_;
+      }
+      break;
+    }
+    case kFollowing: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.following_;
+      }
+      break;
+    }
+    case kCurrentRow: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.current_row_;
+      }
+      break;
+    }
+    case kUnbounded: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.unbounded_;
+      }
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = KIND_NOT_SET;
+}
+
+
+void Expression_WindowFunction_Bound::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_kind();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_WindowFunction_Bound::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_preceding(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.WindowFunction.Bound.Following following = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_following(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_current_row(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_unbounded(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_WindowFunction_Bound::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1;
+  if (_internal_has_preceding()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::preceding(this), target, stream);
+  }
+
+  // .substrait.Expression.WindowFunction.Bound.Following following = 2;
+  if (_internal_has_following()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::following(this), target, stream);
+  }
+
+  // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3;
+  if (_internal_has_current_row()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::current_row(this), target, stream);
+  }
+
+  // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4;
+  if (_internal_has_unbounded()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::unbounded(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound)
+  return target;
+}
+
+size_t Expression_WindowFunction_Bound::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (kind_case()) {
+    // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1;
+    case kPreceding: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.preceding_);
+      break;
+    }
+    // .substrait.Expression.WindowFunction.Bound.Following following = 2;
+    case kFollowing: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.following_);
+      break;
+    }
+    // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3;
+    case kCurrentRow: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.current_row_);
+      break;
+    }
+    // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4;
+    case kUnbounded: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.unbounded_);
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_WindowFunction_Bound::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound::GetClassData() const { return &_class_data_; }
+
+void Expression_WindowFunction_Bound::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_WindowFunction_Bound *>(to)->MergeFrom(
+      static_cast<const Expression_WindowFunction_Bound &>(from));
+}
+
+
+void Expression_WindowFunction_Bound::MergeFrom(const Expression_WindowFunction_Bound& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.kind_case()) {
+    case kPreceding: {
+      _internal_mutable_preceding()->::substrait::Expression_WindowFunction_Bound_Preceding::MergeFrom(from._internal_preceding());
+      break;
+    }
+    case kFollowing: {
+      _internal_mutable_following()->::substrait::Expression_WindowFunction_Bound_Following::MergeFrom(from._internal_following());
+      break;
+    }
+    case kCurrentRow: {
+      _internal_mutable_current_row()->::substrait::Expression_WindowFunction_Bound_CurrentRow::MergeFrom(from._internal_current_row());
+      break;
+    }
+    case kUnbounded: {
+      _internal_mutable_unbounded()->::substrait::Expression_WindowFunction_Bound_Unbounded::MergeFrom(from._internal_unbounded());
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_WindowFunction_Bound::CopyFrom(const Expression_WindowFunction_Bound& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_WindowFunction_Bound::IsInitialized() const {
+  return true;
+}
+
+void Expression_WindowFunction_Bound::InternalSwap(Expression_WindowFunction_Bound* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(kind_, other->kind_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[16]);
+}
+
+// ===================================================================
+
+class Expression_WindowFunction::_Internal {
+ public:
+  static const ::substrait::Expression_WindowFunction_Bound& upper_bound(const Expression_WindowFunction* msg);
+  static const ::substrait::Expression_WindowFunction_Bound& lower_bound(const Expression_WindowFunction* msg);
+  static const ::substrait::Type& output_type(const Expression_WindowFunction* msg);
+};
+
+const ::substrait::Expression_WindowFunction_Bound&
+Expression_WindowFunction::_Internal::upper_bound(const Expression_WindowFunction* msg) {
+  return *msg->upper_bound_;
+}
+const ::substrait::Expression_WindowFunction_Bound&
+Expression_WindowFunction::_Internal::lower_bound(const Expression_WindowFunction* msg) {
+  return *msg->lower_bound_;
+}
+const ::substrait::Type&
+Expression_WindowFunction::_Internal::output_type(const Expression_WindowFunction* msg) {
+  return *msg->output_type_;
+}
+void Expression_WindowFunction::clear_output_type() {
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+}
+Expression_WindowFunction::Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  partitions_(arena),
+  sorts_(arena),
+  args_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction)
+}
+Expression_WindowFunction::Expression_WindowFunction(const Expression_WindowFunction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      partitions_(from.partitions_),
+      sorts_(from.sorts_),
+      args_(from.args_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_upper_bound()) {
+    upper_bound_ = new ::substrait::Expression_WindowFunction_Bound(*from.upper_bound_);
+  } else {
+    upper_bound_ = nullptr;
+  }
+  if (from._internal_has_lower_bound()) {
+    lower_bound_ = new ::substrait::Expression_WindowFunction_Bound(*from.lower_bound_);
+  } else {
+    lower_bound_ = nullptr;
+  }
+  if (from._internal_has_output_type()) {
+    output_type_ = new ::substrait::Type(*from.output_type_);
+  } else {
+    output_type_ = nullptr;
+  }
+  ::memcpy(&function_reference_, &from.function_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&phase_) -
+    reinterpret_cast<char*>(&function_reference_)) + sizeof(phase_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction)
+}
+
+inline void Expression_WindowFunction::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&upper_bound_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&phase_) -
+    reinterpret_cast<char*>(&upper_bound_)) + sizeof(phase_));
+}
+
+Expression_WindowFunction::~Expression_WindowFunction() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_WindowFunction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete upper_bound_;
+  if (this != internal_default_instance()) delete lower_bound_;
+  if (this != internal_default_instance()) delete output_type_;
+}
+
+void Expression_WindowFunction::ArenaDtor(void* object) {
+  Expression_WindowFunction* _this = reinterpret_cast< Expression_WindowFunction* >(object);
+  (void)_this;
+}
+void Expression_WindowFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_WindowFunction::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_WindowFunction::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  partitions_.Clear();
+  sorts_.Clear();
+  args_.Clear();
+  if (GetArenaForAllocation() == nullptr && upper_bound_ != nullptr) {
+    delete upper_bound_;
+  }
+  upper_bound_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && lower_bound_ != nullptr) {
+    delete lower_bound_;
+  }
+  lower_bound_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+  ::memset(&function_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&phase_) -
+      reinterpret_cast<char*>(&function_reference_)) + sizeof(phase_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 function_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.Expression partitions = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_partitions(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.SortField sorts = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_sorts(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.WindowFunction.Bound upper_bound = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_upper_bound(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.WindowFunction.Bound lower_bound = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_lower_bound(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.AggregationPhase phase = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_phase(static_cast<::substrait::AggregationPhase>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type output_type = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.Expression args = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_args(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_WindowFunction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 function_reference = 1;
+  if (this->_internal_function_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target);
+  }
+
+  // repeated .substrait.Expression partitions = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_partitions_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_partitions(i), target, stream);
+  }
+
+  // repeated .substrait.SortField sorts = 3;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_sorts_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, this->_internal_sorts(i), target, stream);
+  }
+
+  // .substrait.Expression.WindowFunction.Bound upper_bound = 4;
+  if (this->_internal_has_upper_bound()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::upper_bound(this), target, stream);
+  }
+
+  // .substrait.Expression.WindowFunction.Bound lower_bound = 5;
+  if (this->_internal_has_lower_bound()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        5, _Internal::lower_bound(this), target, stream);
+  }
+
+  // .substrait.AggregationPhase phase = 6;
+  if (this->_internal_phase() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      6, this->_internal_phase(), target);
+  }
+
+  // .substrait.Type output_type = 7;
+  if (this->_internal_has_output_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        7, _Internal::output_type(this), target, stream);
+  }
+
+  // repeated .substrait.Expression args = 8;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_args_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(8, this->_internal_args(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction)
+  return target;
+}
+
+size_t Expression_WindowFunction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression partitions = 2;
+  total_size += 1UL * this->_internal_partitions_size();
+  for (const auto& msg : this->partitions_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .substrait.SortField sorts = 3;
+  total_size += 1UL * this->_internal_sorts_size();
+  for (const auto& msg : this->sorts_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .substrait.Expression args = 8;
+  total_size += 1UL * this->_internal_args_size();
+  for (const auto& msg : this->args_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.Expression.WindowFunction.Bound upper_bound = 4;
+  if (this->_internal_has_upper_bound()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *upper_bound_);
+  }
+
+  // .substrait.Expression.WindowFunction.Bound lower_bound = 5;
+  if (this->_internal_has_lower_bound()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *lower_bound_);
+  }
+
+  // .substrait.Type output_type = 7;
+  if (this->_internal_has_output_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *output_type_);
+  }
+
+  // uint32 function_reference = 1;
+  if (this->_internal_function_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_reference());
+  }
+
+  // .substrait.AggregationPhase phase = 6;
+  if (this->_internal_phase() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_WindowFunction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction::GetClassData() const { return &_class_data_; }
+
+void Expression_WindowFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_WindowFunction *>(to)->MergeFrom(
+      static_cast<const Expression_WindowFunction &>(from));
+}
+
+
+void Expression_WindowFunction::MergeFrom(const Expression_WindowFunction& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  partitions_.MergeFrom(from.partitions_);
+  sorts_.MergeFrom(from.sorts_);
+  args_.MergeFrom(from.args_);
+  if (from._internal_has_upper_bound()) {
+    _internal_mutable_upper_bound()->::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_upper_bound());
+  }
+  if (from._internal_has_lower_bound()) {
+    _internal_mutable_lower_bound()->::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_lower_bound());
+  }
+  if (from._internal_has_output_type()) {
+    _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type());
+  }
+  if (from._internal_function_reference() != 0) {
+    _internal_set_function_reference(from._internal_function_reference());
+  }
+  if (from._internal_phase() != 0) {
+    _internal_set_phase(from._internal_phase());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_WindowFunction::CopyFrom(const Expression_WindowFunction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_WindowFunction::IsInitialized() const {
+  return true;
+}
+
+void Expression_WindowFunction::InternalSwap(Expression_WindowFunction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  partitions_.InternalSwap(&other->partitions_);
+  sorts_.InternalSwap(&other->sorts_);
+  args_.InternalSwap(&other->args_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_WindowFunction, phase_)
+      + sizeof(Expression_WindowFunction::phase_)
+      - PROTOBUF_FIELD_OFFSET(Expression_WindowFunction, upper_bound_)>(
+          reinterpret_cast<char*>(&upper_bound_),
+          reinterpret_cast<char*>(&other->upper_bound_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[17]);
+}
+
+// ===================================================================
+
+class Expression_IfThen_IfClause::_Internal {
+ public:
+  static const ::substrait::Expression& if_(const Expression_IfThen_IfClause* msg);
+  static const ::substrait::Expression& then(const Expression_IfThen_IfClause* msg);
+};
+
+const ::substrait::Expression&
+Expression_IfThen_IfClause::_Internal::if_(const Expression_IfThen_IfClause* msg) {
+  return *msg->if__;
+}
+const ::substrait::Expression&
+Expression_IfThen_IfClause::_Internal::then(const Expression_IfThen_IfClause* msg) {
+  return *msg->then_;
+}
+Expression_IfThen_IfClause::Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.IfThen.IfClause)
+}
+Expression_IfThen_IfClause::Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_if_()) {
+    if__ = new ::substrait::Expression(*from.if__);
+  } else {
+    if__ = nullptr;
+  }
+  if (from._internal_has_then()) {
+    then_ = new ::substrait::Expression(*from.then_);
+  } else {
+    then_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.IfThen.IfClause)
+}
+
+inline void Expression_IfThen_IfClause::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&if__) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&then_) -
+    reinterpret_cast<char*>(&if__)) + sizeof(then_));
+}
+
+Expression_IfThen_IfClause::~Expression_IfThen_IfClause() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.IfThen.IfClause)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_IfThen_IfClause::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete if__;
+  if (this != internal_default_instance()) delete then_;
+}
+
+void Expression_IfThen_IfClause::ArenaDtor(void* object) {
+  Expression_IfThen_IfClause* _this = reinterpret_cast< Expression_IfThen_IfClause* >(object);
+  (void)_this;
+}
+void Expression_IfThen_IfClause::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_IfThen_IfClause::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_IfThen_IfClause::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.IfThen.IfClause)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && if__ != nullptr) {
+    delete if__;
+  }
+  if__ = nullptr;
+  if (GetArenaForAllocation() == nullptr && then_ != nullptr) {
+    delete then_;
+  }
+  then_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_IfThen_IfClause::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression if = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression then = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_then(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_IfThen_IfClause::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.IfThen.IfClause)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression if = 1;
+  if (this->_internal_has_if_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::if_(this), target, stream);
+  }
+
+  // .substrait.Expression then = 2;
+  if (this->_internal_has_then()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::then(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.IfThen.IfClause)
+  return target;
+}
+
+size_t Expression_IfThen_IfClause::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.IfThen.IfClause)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Expression if = 1;
+  if (this->_internal_has_if_()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *if__);
+  }
+
+  // .substrait.Expression then = 2;
+  if (this->_internal_has_then()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *then_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_IfThen_IfClause::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_IfThen_IfClause::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_IfThen_IfClause::GetClassData() const { return &_class_data_; }
+
+void Expression_IfThen_IfClause::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_IfThen_IfClause *>(to)->MergeFrom(
+      static_cast<const Expression_IfThen_IfClause &>(from));
+}
+
+
+void Expression_IfThen_IfClause::MergeFrom(const Expression_IfThen_IfClause& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.IfThen.IfClause)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_if_()) {
+    _internal_mutable_if_()->::substrait::Expression::MergeFrom(from._internal_if_());
+  }
+  if (from._internal_has_then()) {
+    _internal_mutable_then()->::substrait::Expression::MergeFrom(from._internal_then());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_IfThen_IfClause::CopyFrom(const Expression_IfThen_IfClause& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.IfThen.IfClause)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_IfThen_IfClause::IsInitialized() const {
+  return true;
+}
+
+void Expression_IfThen_IfClause::InternalSwap(Expression_IfThen_IfClause* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_IfThen_IfClause, then_)
+      + sizeof(Expression_IfThen_IfClause::then_)
+      - PROTOBUF_FIELD_OFFSET(Expression_IfThen_IfClause, if__)>(
+          reinterpret_cast<char*>(&if__),
+          reinterpret_cast<char*>(&other->if__));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen_IfClause::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[18]);
+}
+
+// ===================================================================
+
+class Expression_IfThen::_Internal {
+ public:
+  static const ::substrait::Expression& else_(const Expression_IfThen* msg);
+};
+
+const ::substrait::Expression&
+Expression_IfThen::_Internal::else_(const Expression_IfThen* msg) {
+  return *msg->else__;
+}
+Expression_IfThen::Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  ifs_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.IfThen)
+}
+Expression_IfThen::Expression_IfThen(const Expression_IfThen& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      ifs_(from.ifs_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_else_()) {
+    else__ = new ::substrait::Expression(*from.else__);
+  } else {
+    else__ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.IfThen)
+}
+
+inline void Expression_IfThen::SharedCtor() {
+else__ = nullptr;
+}
+
+Expression_IfThen::~Expression_IfThen() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.IfThen)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_IfThen::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete else__;
+}
+
+void Expression_IfThen::ArenaDtor(void* object) {
+  Expression_IfThen* _this = reinterpret_cast< Expression_IfThen* >(object);
+  (void)_this;
+}
+void Expression_IfThen::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_IfThen::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_IfThen::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.IfThen)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ifs_.Clear();
+  if (GetArenaForAllocation() == nullptr && else__ != nullptr) {
+    delete else__;
+  }
+  else__ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_IfThen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Expression.IfThen.IfClause ifs = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_ifs(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression else = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_else_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_IfThen::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.IfThen)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.IfThen.IfClause ifs = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_ifs_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_ifs(i), target, stream);
+  }
+
+  // .substrait.Expression else = 2;
+  if (this->_internal_has_else_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::else_(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.IfThen)
+  return target;
+}
+
+size_t Expression_IfThen::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.IfThen)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.IfThen.IfClause ifs = 1;
+  total_size += 1UL * this->_internal_ifs_size();
+  for (const auto& msg : this->ifs_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.Expression else = 2;
+  if (this->_internal_has_else_()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *else__);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_IfThen::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_IfThen::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_IfThen::GetClassData() const { return &_class_data_; }
+
+void Expression_IfThen::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_IfThen *>(to)->MergeFrom(
+      static_cast<const Expression_IfThen &>(from));
+}
+
+
+void Expression_IfThen::MergeFrom(const Expression_IfThen& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.IfThen)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  ifs_.MergeFrom(from.ifs_);
+  if (from._internal_has_else_()) {
+    _internal_mutable_else_()->::substrait::Expression::MergeFrom(from._internal_else_());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_IfThen::CopyFrom(const Expression_IfThen& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.IfThen)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_IfThen::IsInitialized() const {
+  return true;
+}
+
+void Expression_IfThen::InternalSwap(Expression_IfThen* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ifs_.InternalSwap(&other->ifs_);
+  swap(else__, other->else__);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[19]);
+}
+
+// ===================================================================
+
+class Expression_Cast::_Internal {
+ public:
+  static const ::substrait::Type& type(const Expression_Cast* msg);
+  static const ::substrait::Expression& input(const Expression_Cast* msg);
+};
+
+const ::substrait::Type&
+Expression_Cast::_Internal::type(const Expression_Cast* msg) {
+  return *msg->type_;
+}
+const ::substrait::Expression&
+Expression_Cast::_Internal::input(const Expression_Cast* msg) {
+  return *msg->input_;
+}
+void Expression_Cast::clear_type() {
+  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
+    delete type_;
+  }
+  type_ = nullptr;
+}
+Expression_Cast::Expression_Cast(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.Cast)
+}
+Expression_Cast::Expression_Cast(const Expression_Cast& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_type()) {
+    type_ = new ::substrait::Type(*from.type_);
+  } else {
+    type_ = nullptr;
+  }
+  if (from._internal_has_input()) {
+    input_ = new ::substrait::Expression(*from.input_);
+  } else {
+    input_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.Cast)
+}
+
+inline void Expression_Cast::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&input_) -
+    reinterpret_cast<char*>(&type_)) + sizeof(input_));
+}
+
+Expression_Cast::~Expression_Cast() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.Cast)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_Cast::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete type_;
+  if (this != internal_default_instance()) delete input_;
+}
+
+void Expression_Cast::ArenaDtor(void* object) {
+  Expression_Cast* _this = reinterpret_cast< Expression_Cast* >(object);
+  (void)_this;
+}
+void Expression_Cast::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_Cast::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_Cast::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.Cast)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
+    delete type_;
+  }
+  type_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_Cast::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Type type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression input = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_Cast::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Cast)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Type type = 1;
+  if (this->_internal_has_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::type(this), target, stream);
+  }
+
+  // .substrait.Expression input = 2;
+  if (this->_internal_has_input()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::input(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Cast)
+  return target;
+}
+
+size_t Expression_Cast::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Cast)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Type type = 1;
+  if (this->_internal_has_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *type_);
+  }
+
+  // .substrait.Expression input = 2;
+  if (this->_internal_has_input()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *input_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Cast::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_Cast::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Cast::GetClassData() const { return &_class_data_; }
+
+void Expression_Cast::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_Cast *>(to)->MergeFrom(
+      static_cast<const Expression_Cast &>(from));
+}
+
+
+void Expression_Cast::MergeFrom(const Expression_Cast& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Cast)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_type()) {
+    _internal_mutable_type()->::substrait::Type::MergeFrom(from._internal_type());
+  }
+  if (from._internal_has_input()) {
+    _internal_mutable_input()->::substrait::Expression::MergeFrom(from._internal_input());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_Cast::CopyFrom(const Expression_Cast& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Cast)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_Cast::IsInitialized() const {
+  return true;
+}
+
+void Expression_Cast::InternalSwap(Expression_Cast* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_Cast, input_)
+      + sizeof(Expression_Cast::input_)
+      - PROTOBUF_FIELD_OFFSET(Expression_Cast, type_)>(
+          reinterpret_cast<char*>(&type_),
+          reinterpret_cast<char*>(&other->type_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_Cast::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[20]);
+}
+
+// ===================================================================
+
+class Expression_SwitchExpression_IfValue::_Internal {
+ public:
+  static const ::substrait::Expression_Literal& if_(const Expression_SwitchExpression_IfValue* msg);
+  static const ::substrait::Expression& then(const Expression_SwitchExpression_IfValue* msg);
+};
+
+const ::substrait::Expression_Literal&
+Expression_SwitchExpression_IfValue::_Internal::if_(const Expression_SwitchExpression_IfValue* msg) {
+  return *msg->if__;
+}
+const ::substrait::Expression&
+Expression_SwitchExpression_IfValue::_Internal::then(const Expression_SwitchExpression_IfValue* msg) {
+  return *msg->then_;
+}
+Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.SwitchExpression.IfValue)
+}
+Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(const Expression_SwitchExpression_IfValue& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_if_()) {
+    if__ = new ::substrait::Expression_Literal(*from.if__);
+  } else {
+    if__ = nullptr;
+  }
+  if (from._internal_has_then()) {
+    then_ = new ::substrait::Expression(*from.then_);
+  } else {
+    then_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.SwitchExpression.IfValue)
+}
+
+inline void Expression_SwitchExpression_IfValue::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&if__) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&then_) -
+    reinterpret_cast<char*>(&if__)) + sizeof(then_));
+}
+
+Expression_SwitchExpression_IfValue::~Expression_SwitchExpression_IfValue() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.SwitchExpression.IfValue)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_SwitchExpression_IfValue::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete if__;
+  if (this != internal_default_instance()) delete then_;
+}
+
+void Expression_SwitchExpression_IfValue::ArenaDtor(void* object) {
+  Expression_SwitchExpression_IfValue* _this = reinterpret_cast< Expression_SwitchExpression_IfValue* >(object);
+  (void)_this;
+}
+void Expression_SwitchExpression_IfValue::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_SwitchExpression_IfValue::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_SwitchExpression_IfValue::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.SwitchExpression.IfValue)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && if__ != nullptr) {
+    delete if__;
+  }
+  if__ = nullptr;
+  if (GetArenaForAllocation() == nullptr && then_ != nullptr) {
+    delete then_;
+  }
+  then_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_SwitchExpression_IfValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression.Literal if = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression then = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_then(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_SwitchExpression_IfValue::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SwitchExpression.IfValue)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression.Literal if = 1;
+  if (this->_internal_has_if_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::if_(this), target, stream);
+  }
+
+  // .substrait.Expression then = 2;
+  if (this->_internal_has_then()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::then(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.SwitchExpression.IfValue)
+  return target;
+}
+
+size_t Expression_SwitchExpression_IfValue::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SwitchExpression.IfValue)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Expression.Literal if = 1;
+  if (this->_internal_has_if_()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *if__);
+  }
+
+  // .substrait.Expression then = 2;
+  if (this->_internal_has_then()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *then_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_SwitchExpression_IfValue::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_SwitchExpression_IfValue::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_SwitchExpression_IfValue::GetClassData() const { return &_class_data_; }
+
+void Expression_SwitchExpression_IfValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_SwitchExpression_IfValue *>(to)->MergeFrom(
+      static_cast<const Expression_SwitchExpression_IfValue &>(from));
+}
+
+
+void Expression_SwitchExpression_IfValue::MergeFrom(const Expression_SwitchExpression_IfValue& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.SwitchExpression.IfValue)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_if_()) {
+    _internal_mutable_if_()->::substrait::Expression_Literal::MergeFrom(from._internal_if_());
+  }
+  if (from._internal_has_then()) {
+    _internal_mutable_then()->::substrait::Expression::MergeFrom(from._internal_then());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_SwitchExpression_IfValue::CopyFrom(const Expression_SwitchExpression_IfValue& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.SwitchExpression.IfValue)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_SwitchExpression_IfValue::IsInitialized() const {
+  return true;
+}
+
+void Expression_SwitchExpression_IfValue::InternalSwap(Expression_SwitchExpression_IfValue* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_SwitchExpression_IfValue, then_)
+      + sizeof(Expression_SwitchExpression_IfValue::then_)
+      - PROTOBUF_FIELD_OFFSET(Expression_SwitchExpression_IfValue, if__)>(
+          reinterpret_cast<char*>(&if__),
+          reinterpret_cast<char*>(&other->if__));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_SwitchExpression_IfValue::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[21]);
+}
+
+// ===================================================================
+
+class Expression_SwitchExpression::_Internal {
+ public:
+  static const ::substrait::Expression& else_(const Expression_SwitchExpression* msg);
+};
+
+const ::substrait::Expression&
+Expression_SwitchExpression::_Internal::else_(const Expression_SwitchExpression* msg) {
+  return *msg->else__;
+}
+Expression_SwitchExpression::Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  ifs_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.SwitchExpression)
+}
+Expression_SwitchExpression::Expression_SwitchExpression(const Expression_SwitchExpression& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      ifs_(from.ifs_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_else_()) {
+    else__ = new ::substrait::Expression(*from.else__);
+  } else {
+    else__ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.SwitchExpression)
+}
+
+inline void Expression_SwitchExpression::SharedCtor() {
+else__ = nullptr;
+}
+
+Expression_SwitchExpression::~Expression_SwitchExpression() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.SwitchExpression)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_SwitchExpression::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete else__;
+}
+
+void Expression_SwitchExpression::ArenaDtor(void* object) {
+  Expression_SwitchExpression* _this = reinterpret_cast< Expression_SwitchExpression* >(object);
+  (void)_this;
+}
+void Expression_SwitchExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_SwitchExpression::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_SwitchExpression::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.SwitchExpression)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ifs_.Clear();
+  if (GetArenaForAllocation() == nullptr && else__ != nullptr) {
+    delete else__;
+  }
+  else__ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_SwitchExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_ifs(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression else = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_else_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_SwitchExpression::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SwitchExpression)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_ifs_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_ifs(i), target, stream);
+  }
+
+  // .substrait.Expression else = 2;
+  if (this->_internal_has_else_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::else_(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.SwitchExpression)
+  return target;
+}
+
+size_t Expression_SwitchExpression::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SwitchExpression)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1;
+  total_size += 1UL * this->_internal_ifs_size();
+  for (const auto& msg : this->ifs_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.Expression else = 2;
+  if (this->_internal_has_else_()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *else__);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_SwitchExpression::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_SwitchExpression::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_SwitchExpression::GetClassData() const { return &_class_data_; }
+
+void Expression_SwitchExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_SwitchExpression *>(to)->MergeFrom(
+      static_cast<const Expression_SwitchExpression &>(from));
+}
+
+
+void Expression_SwitchExpression::MergeFrom(const Expression_SwitchExpression& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.SwitchExpression)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  ifs_.MergeFrom(from.ifs_);
+  if (from._internal_has_else_()) {
+    _internal_mutable_else_()->::substrait::Expression::MergeFrom(from._internal_else_());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_SwitchExpression::CopyFrom(const Expression_SwitchExpression& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.SwitchExpression)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_SwitchExpression::IsInitialized() const {
+  return true;
+}
+
+void Expression_SwitchExpression::InternalSwap(Expression_SwitchExpression* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ifs_.InternalSwap(&other->ifs_);
+  swap(else__, other->else__);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_SwitchExpression::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[22]);
+}
+
+// ===================================================================
+
+class Expression_SingularOrList::_Internal {
+ public:
+  static const ::substrait::Expression& value(const Expression_SingularOrList* msg);
+};
+
+const ::substrait::Expression&
+Expression_SingularOrList::_Internal::value(const Expression_SingularOrList* msg) {
+  return *msg->value_;
+}
+Expression_SingularOrList::Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  options_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.SingularOrList)
+}
+Expression_SingularOrList::Expression_SingularOrList(const Expression_SingularOrList& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      options_(from.options_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_value()) {
+    value_ = new ::substrait::Expression(*from.value_);
+  } else {
+    value_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.SingularOrList)
+}
+
+inline void Expression_SingularOrList::SharedCtor() {
+value_ = nullptr;
+}
+
+Expression_SingularOrList::~Expression_SingularOrList() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.SingularOrList)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_SingularOrList::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete value_;
+}
+
+void Expression_SingularOrList::ArenaDtor(void* object) {
+  Expression_SingularOrList* _this = reinterpret_cast< Expression_SingularOrList* >(object);
+  (void)_this;
+}
+void Expression_SingularOrList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_SingularOrList::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_SingularOrList::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.SingularOrList)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  options_.Clear();
+  if (GetArenaForAllocation() == nullptr && value_ != nullptr) {
+    delete value_;
+  }
+  value_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_SingularOrList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression value = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.Expression options = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_options(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_SingularOrList::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SingularOrList)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression value = 1;
+  if (this->_internal_has_value()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::value(this), target, stream);
+  }
+
+  // repeated .substrait.Expression options = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_options_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_options(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.SingularOrList)
+  return target;
+}
+
+size_t Expression_SingularOrList::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SingularOrList)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression options = 2;
+  total_size += 1UL * this->_internal_options_size();
+  for (const auto& msg : this->options_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.Expression value = 1;
+  if (this->_internal_has_value()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *value_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_SingularOrList::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_SingularOrList::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_SingularOrList::GetClassData() const { return &_class_data_; }
+
+void Expression_SingularOrList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_SingularOrList *>(to)->MergeFrom(
+      static_cast<const Expression_SingularOrList &>(from));
+}
+
+
+void Expression_SingularOrList::MergeFrom(const Expression_SingularOrList& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.SingularOrList)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  options_.MergeFrom(from.options_);
+  if (from._internal_has_value()) {
+    _internal_mutable_value()->::substrait::Expression::MergeFrom(from._internal_value());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_SingularOrList::CopyFrom(const Expression_SingularOrList& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.SingularOrList)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_SingularOrList::IsInitialized() const {
+  return true;
+}
+
+void Expression_SingularOrList::InternalSwap(Expression_SingularOrList* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  options_.InternalSwap(&other->options_);
+  swap(value_, other->value_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_SingularOrList::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[23]);
+}
+
+// ===================================================================
+
+class Expression_MultiOrList_Record::_Internal {
+ public:
+};
+
+Expression_MultiOrList_Record::Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  fields_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MultiOrList.Record)
+}
+Expression_MultiOrList_Record::Expression_MultiOrList_Record(const Expression_MultiOrList_Record& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      fields_(from.fields_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MultiOrList.Record)
+}
+
+inline void Expression_MultiOrList_Record::SharedCtor() {
+}
+
+Expression_MultiOrList_Record::~Expression_MultiOrList_Record() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MultiOrList.Record)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MultiOrList_Record::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Expression_MultiOrList_Record::ArenaDtor(void* object) {
+  Expression_MultiOrList_Record* _this = reinterpret_cast< Expression_MultiOrList_Record* >(object);
+  (void)_this;
+}
+void Expression_MultiOrList_Record::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MultiOrList_Record::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MultiOrList_Record::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MultiOrList.Record)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  fields_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MultiOrList_Record::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Expression fields = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_fields(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MultiOrList_Record::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MultiOrList.Record)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression fields = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_fields_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_fields(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MultiOrList.Record)
+  return target;
+}
+
+size_t Expression_MultiOrList_Record::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MultiOrList.Record)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression fields = 1;
+  total_size += 1UL * this->_internal_fields_size();
+  for (const auto& msg : this->fields_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MultiOrList_Record::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MultiOrList_Record::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MultiOrList_Record::GetClassData() const { return &_class_data_; }
+
+void Expression_MultiOrList_Record::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MultiOrList_Record *>(to)->MergeFrom(
+      static_cast<const Expression_MultiOrList_Record &>(from));
+}
+
+
+void Expression_MultiOrList_Record::MergeFrom(const Expression_MultiOrList_Record& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MultiOrList.Record)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  fields_.MergeFrom(from.fields_);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MultiOrList_Record::CopyFrom(const Expression_MultiOrList_Record& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MultiOrList.Record)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MultiOrList_Record::IsInitialized() const {
+  return true;
+}
+
+void Expression_MultiOrList_Record::InternalSwap(Expression_MultiOrList_Record* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  fields_.InternalSwap(&other->fields_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MultiOrList_Record::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[24]);
+}
+
+// ===================================================================
+
+class Expression_MultiOrList::_Internal {
+ public:
+};
+
+Expression_MultiOrList::Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  value_(arena),
+  options_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MultiOrList)
+}
+Expression_MultiOrList::Expression_MultiOrList(const Expression_MultiOrList& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      value_(from.value_),
+      options_(from.options_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MultiOrList)
+}
+
+inline void Expression_MultiOrList::SharedCtor() {
+}
+
+Expression_MultiOrList::~Expression_MultiOrList() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MultiOrList)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MultiOrList::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Expression_MultiOrList::ArenaDtor(void* object) {
+  Expression_MultiOrList* _this = reinterpret_cast< Expression_MultiOrList* >(object);
+  (void)_this;
+}
+void Expression_MultiOrList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MultiOrList::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MultiOrList::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MultiOrList)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  value_.Clear();
+  options_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MultiOrList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Expression value = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_value(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.Expression.MultiOrList.Record options = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_options(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MultiOrList::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MultiOrList)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression value = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_value_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_value(i), target, stream);
+  }
+
+  // repeated .substrait.Expression.MultiOrList.Record options = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_options_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_options(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MultiOrList)
+  return target;
+}
+
+size_t Expression_MultiOrList::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MultiOrList)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression value = 1;
+  total_size += 1UL * this->_internal_value_size();
+  for (const auto& msg : this->value_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .substrait.Expression.MultiOrList.Record options = 2;
+  total_size += 1UL * this->_internal_options_size();
+  for (const auto& msg : this->options_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MultiOrList::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MultiOrList::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MultiOrList::GetClassData() const { return &_class_data_; }
+
+void Expression_MultiOrList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MultiOrList *>(to)->MergeFrom(
+      static_cast<const Expression_MultiOrList &>(from));
+}
+
+
+void Expression_MultiOrList::MergeFrom(const Expression_MultiOrList& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MultiOrList)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  value_.MergeFrom(from.value_);
+  options_.MergeFrom(from.options_);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MultiOrList::CopyFrom(const Expression_MultiOrList& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MultiOrList)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MultiOrList::IsInitialized() const {
+  return true;
+}
+
+void Expression_MultiOrList::InternalSwap(Expression_MultiOrList* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  value_.InternalSwap(&other->value_);
+  options_.InternalSwap(&other->options_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MultiOrList::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[25]);
+}
+
+// ===================================================================
+
+class Expression_EmbeddedFunction_PythonPickleFunction::_Internal {
+ public:
+};
+
+Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  prerequisite_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
+}
+Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(const Expression_EmbeddedFunction_PythonPickleFunction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      prerequisite_(from.prerequisite_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    function_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_function().empty()) {
+    function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_function(), 
+      GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
+}
+
+inline void Expression_EmbeddedFunction_PythonPickleFunction::SharedCtor() {
+function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  function_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Expression_EmbeddedFunction_PythonPickleFunction::~Expression_EmbeddedFunction_PythonPickleFunction() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_EmbeddedFunction_PythonPickleFunction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  function_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Expression_EmbeddedFunction_PythonPickleFunction::ArenaDtor(void* object) {
+  Expression_EmbeddedFunction_PythonPickleFunction* _this = reinterpret_cast< Expression_EmbeddedFunction_PythonPickleFunction* >(object);
+  (void)_this;
+}
+void Expression_EmbeddedFunction_PythonPickleFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_EmbeddedFunction_PythonPickleFunction::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_EmbeddedFunction_PythonPickleFunction::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  prerequisite_.Clear();
+  function_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_EmbeddedFunction_PythonPickleFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // bytes function = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_function();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string prerequisite = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_prerequisite();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_EmbeddedFunction_PythonPickleFunction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes function = 1;
+  if (!this->_internal_function().empty()) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_function(), target);
+  }
+
+  // repeated string prerequisite = 2;
+  for (int i = 0, n = this->_internal_prerequisite_size(); i < n; i++) {
+    const auto& s = this->_internal_prerequisite(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite");
+    target = stream->WriteString(2, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
+  return target;
+}
+
+size_t Expression_EmbeddedFunction_PythonPickleFunction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string prerequisite = 2;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(prerequisite_.size());
+  for (int i = 0, n = prerequisite_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      prerequisite_.Get(i));
+  }
+
+  // bytes function = 1;
+  if (!this->_internal_function().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_function());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_EmbeddedFunction_PythonPickleFunction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_EmbeddedFunction_PythonPickleFunction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_EmbeddedFunction_PythonPickleFunction::GetClassData() const { return &_class_data_; }
+
+void Expression_EmbeddedFunction_PythonPickleFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_EmbeddedFunction_PythonPickleFunction *>(to)->MergeFrom(
+      static_cast<const Expression_EmbeddedFunction_PythonPickleFunction &>(from));
+}
+
+
+void Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  prerequisite_.MergeFrom(from.prerequisite_);
+  if (!from._internal_function().empty()) {
+    _internal_set_function(from._internal_function());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_EmbeddedFunction_PythonPickleFunction::CopyFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_EmbeddedFunction_PythonPickleFunction::IsInitialized() const {
+  return true;
+}
+
+void Expression_EmbeddedFunction_PythonPickleFunction::InternalSwap(Expression_EmbeddedFunction_PythonPickleFunction* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  prerequisite_.InternalSwap(&other->prerequisite_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &function_, lhs_arena,
+      &other->function_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_PythonPickleFunction::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[26]);
+}
+
+// ===================================================================
+
+class Expression_EmbeddedFunction_WebAssemblyFunction::_Internal {
+ public:
+};
+
+Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  prerequisite_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
+}
+Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(const Expression_EmbeddedFunction_WebAssemblyFunction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      prerequisite_(from.prerequisite_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  script_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    script_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_script().empty()) {
+    script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_script(), 
+      GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
+}
+
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::SharedCtor() {
+script_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  script_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Expression_EmbeddedFunction_WebAssemblyFunction::~Expression_EmbeddedFunction_WebAssemblyFunction() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  script_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Expression_EmbeddedFunction_WebAssemblyFunction::ArenaDtor(void* object) {
+  Expression_EmbeddedFunction_WebAssemblyFunction* _this = reinterpret_cast< Expression_EmbeddedFunction_WebAssemblyFunction* >(object);
+  (void)_this;
+}
+void Expression_EmbeddedFunction_WebAssemblyFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_EmbeddedFunction_WebAssemblyFunction::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_EmbeddedFunction_WebAssemblyFunction::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  prerequisite_.Clear();
+  script_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // bytes script = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_script();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string prerequisite = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_prerequisite();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // bytes script = 1;
+  if (!this->_internal_script().empty()) {
+    target = stream->WriteBytesMaybeAliased(
+        1, this->_internal_script(), target);
+  }
+
+  // repeated string prerequisite = 2;
+  for (int i = 0, n = this->_internal_prerequisite_size(); i < n; i++) {
+    const auto& s = this->_internal_prerequisite(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite");
+    target = stream->WriteString(2, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
+  return target;
+}
+
+size_t Expression_EmbeddedFunction_WebAssemblyFunction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string prerequisite = 2;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(prerequisite_.size());
+  for (int i = 0, n = prerequisite_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      prerequisite_.Get(i));
+  }
+
+  // bytes script = 1;
+  if (!this->_internal_script().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
+        this->_internal_script());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_EmbeddedFunction_WebAssemblyFunction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_EmbeddedFunction_WebAssemblyFunction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_EmbeddedFunction_WebAssemblyFunction::GetClassData() const { return &_class_data_; }
+
+void Expression_EmbeddedFunction_WebAssemblyFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_EmbeddedFunction_WebAssemblyFunction *>(to)->MergeFrom(
+      static_cast<const Expression_EmbeddedFunction_WebAssemblyFunction &>(from));
+}
+
+
+void Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  prerequisite_.MergeFrom(from.prerequisite_);
+  if (!from._internal_script().empty()) {
+    _internal_set_script(from._internal_script());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_EmbeddedFunction_WebAssemblyFunction::CopyFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_EmbeddedFunction_WebAssemblyFunction::IsInitialized() const {
+  return true;
+}
+
+void Expression_EmbeddedFunction_WebAssemblyFunction::InternalSwap(Expression_EmbeddedFunction_WebAssemblyFunction* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  prerequisite_.InternalSwap(&other->prerequisite_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &script_, lhs_arena,
+      &other->script_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_WebAssemblyFunction::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[27]);
+}
+
+// ===================================================================
+
+class Expression_EmbeddedFunction::_Internal {
+ public:
+  static const ::substrait::Type& output_type(const Expression_EmbeddedFunction* msg);
+  static const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& python_pickle_function(const Expression_EmbeddedFunction* msg);
+  static const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& web_assembly_function(const Expression_EmbeddedFunction* msg);
+};
+
+const ::substrait::Type&
+Expression_EmbeddedFunction::_Internal::output_type(const Expression_EmbeddedFunction* msg) {
+  return *msg->output_type_;
+}
+const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction&
+Expression_EmbeddedFunction::_Internal::python_pickle_function(const Expression_EmbeddedFunction* msg) {
+  return *msg->kind_.python_pickle_function_;
+}
+const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction&
+Expression_EmbeddedFunction::_Internal::web_assembly_function(const Expression_EmbeddedFunction* msg) {
+  return *msg->kind_.web_assembly_function_;
+}
+void Expression_EmbeddedFunction::clear_output_type() {
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+}
+void Expression_EmbeddedFunction::set_allocated_python_pickle_function(::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (python_pickle_function) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_EmbeddedFunction_PythonPickleFunction>::GetOwningArena(python_pickle_function);
+    if (message_arena != submessage_arena) {
+      python_pickle_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, python_pickle_function, submessage_arena);
+    }
+    set_has_python_pickle_function();
+    kind_.python_pickle_function_ = python_pickle_function;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.python_pickle_function)
+}
+void Expression_EmbeddedFunction::set_allocated_web_assembly_function(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (web_assembly_function) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_EmbeddedFunction_WebAssemblyFunction>::GetOwningArena(web_assembly_function);
+    if (message_arena != submessage_arena) {
+      web_assembly_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, web_assembly_function, submessage_arena);
+    }
+    set_has_web_assembly_function();
+    kind_.web_assembly_function_ = web_assembly_function;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.web_assembly_function)
+}
+Expression_EmbeddedFunction::Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  arguments_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction)
+}
+Expression_EmbeddedFunction::Expression_EmbeddedFunction(const Expression_EmbeddedFunction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      arguments_(from.arguments_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_output_type()) {
+    output_type_ = new ::substrait::Type(*from.output_type_);
+  } else {
+    output_type_ = nullptr;
+  }
+  clear_has_kind();
+  switch (from.kind_case()) {
+    case kPythonPickleFunction: {
+      _internal_mutable_python_pickle_function()->::substrait::Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(from._internal_python_pickle_function());
+      break;
+    }
+    case kWebAssemblyFunction: {
+      _internal_mutable_web_assembly_function()->::substrait::Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(from._internal_web_assembly_function());
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction)
+}
+
+inline void Expression_EmbeddedFunction::SharedCtor() {
+output_type_ = nullptr;
+clear_has_kind();
+}
+
+Expression_EmbeddedFunction::~Expression_EmbeddedFunction() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.EmbeddedFunction)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_EmbeddedFunction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete output_type_;
+  if (has_kind()) {
+    clear_kind();
+  }
+}
+
+void Expression_EmbeddedFunction::ArenaDtor(void* object) {
+  Expression_EmbeddedFunction* _this = reinterpret_cast< Expression_EmbeddedFunction* >(object);
+  (void)_this;
+}
+void Expression_EmbeddedFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_EmbeddedFunction::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_EmbeddedFunction::clear_kind() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.EmbeddedFunction)
+  switch (kind_case()) {
+    case kPythonPickleFunction: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.python_pickle_function_;
+      }
+      break;
+    }
+    case kWebAssemblyFunction: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.web_assembly_function_;
+      }
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = KIND_NOT_SET;
+}
+
+
+void Expression_EmbeddedFunction::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.EmbeddedFunction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  arguments_.Clear();
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+  clear_kind();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_EmbeddedFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Expression arguments = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_arguments(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type output_type = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_python_pickle_function(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_web_assembly_function(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_EmbeddedFunction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression arguments = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_arguments_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_arguments(i), target, stream);
+  }
+
+  // .substrait.Type output_type = 2;
+  if (this->_internal_has_output_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::output_type(this), target, stream);
+  }
+
+  // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3;
+  if (_internal_has_python_pickle_function()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::python_pickle_function(this), target, stream);
+  }
+
+  // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4;
+  if (_internal_has_web_assembly_function()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::web_assembly_function(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.EmbeddedFunction)
+  return target;
+}
+
+size_t Expression_EmbeddedFunction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression arguments = 1;
+  total_size += 1UL * this->_internal_arguments_size();
+  for (const auto& msg : this->arguments_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.Type output_type = 2;
+  if (this->_internal_has_output_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *output_type_);
+  }
+
+  switch (kind_case()) {
+    // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3;
+    case kPythonPickleFunction: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.python_pickle_function_);
+      break;
+    }
+    // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4;
+    case kWebAssemblyFunction: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.web_assembly_function_);
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_EmbeddedFunction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_EmbeddedFunction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_EmbeddedFunction::GetClassData() const { return &_class_data_; }
+
+void Expression_EmbeddedFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_EmbeddedFunction *>(to)->MergeFrom(
+      static_cast<const Expression_EmbeddedFunction &>(from));
+}
+
+
+void Expression_EmbeddedFunction::MergeFrom(const Expression_EmbeddedFunction& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.EmbeddedFunction)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  arguments_.MergeFrom(from.arguments_);
+  if (from._internal_has_output_type()) {
+    _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type());
+  }
+  switch (from.kind_case()) {
+    case kPythonPickleFunction: {
+      _internal_mutable_python_pickle_function()->::substrait::Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(from._internal_python_pickle_function());
+      break;
+    }
+    case kWebAssemblyFunction: {
+      _internal_mutable_web_assembly_function()->::substrait::Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(from._internal_web_assembly_function());
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_EmbeddedFunction::CopyFrom(const Expression_EmbeddedFunction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.EmbeddedFunction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_EmbeddedFunction::IsInitialized() const {
+  return true;
+}
+
+void Expression_EmbeddedFunction::InternalSwap(Expression_EmbeddedFunction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  arguments_.InternalSwap(&other->arguments_);
+  swap(output_type_, other->output_type_);
+  swap(kind_, other->kind_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[28]);
+}
+
+// ===================================================================
+
+class Expression_ReferenceSegment_MapKey::_Internal {
+ public:
+  static const ::substrait::Expression_Literal& map_key(const Expression_ReferenceSegment_MapKey* msg);
+  static const ::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_MapKey* msg);
+};
+
+const ::substrait::Expression_Literal&
+Expression_ReferenceSegment_MapKey::_Internal::map_key(const Expression_ReferenceSegment_MapKey* msg) {
+  return *msg->map_key_;
+}
+const ::substrait::Expression_ReferenceSegment&
+Expression_ReferenceSegment_MapKey::_Internal::child(const Expression_ReferenceSegment_MapKey* msg) {
+  return *msg->child_;
+}
+Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment.MapKey)
+}
+Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(const Expression_ReferenceSegment_MapKey& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_map_key()) {
+    map_key_ = new ::substrait::Expression_Literal(*from.map_key_);
+  } else {
+    map_key_ = nullptr;
+  }
+  if (from._internal_has_child()) {
+    child_ = new ::substrait::Expression_ReferenceSegment(*from.child_);
+  } else {
+    child_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.MapKey)
+}
+
+inline void Expression_ReferenceSegment_MapKey::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&map_key_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&child_) -
+    reinterpret_cast<char*>(&map_key_)) + sizeof(child_));
+}
+
+Expression_ReferenceSegment_MapKey::~Expression_ReferenceSegment_MapKey() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment.MapKey)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_ReferenceSegment_MapKey::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete map_key_;
+  if (this != internal_default_instance()) delete child_;
+}
+
+void Expression_ReferenceSegment_MapKey::ArenaDtor(void* object) {
+  Expression_ReferenceSegment_MapKey* _this = reinterpret_cast< Expression_ReferenceSegment_MapKey* >(object);
+  (void)_this;
+}
+void Expression_ReferenceSegment_MapKey::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_ReferenceSegment_MapKey::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_ReferenceSegment_MapKey::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment.MapKey)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && map_key_ != nullptr) {
+    delete map_key_;
+  }
+  map_key_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && child_ != nullptr) {
+    delete child_;
+  }
+  child_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_ReferenceSegment_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression.Literal map_key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.ReferenceSegment child = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_child(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_ReferenceSegment_MapKey::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.MapKey)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression.Literal map_key = 1;
+  if (this->_internal_has_map_key()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::map_key(this), target, stream);
+  }
+
+  // .substrait.Expression.ReferenceSegment child = 2;
+  if (this->_internal_has_child()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::child(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ReferenceSegment.MapKey)
+  return target;
+}
+
+size_t Expression_ReferenceSegment_MapKey::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.MapKey)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Expression.Literal map_key = 1;
+  if (this->_internal_has_map_key()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *map_key_);
+  }
+
+  // .substrait.Expression.ReferenceSegment child = 2;
+  if (this->_internal_has_child()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *child_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ReferenceSegment_MapKey::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_ReferenceSegment_MapKey::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ReferenceSegment_MapKey::GetClassData() const { return &_class_data_; }
+
+void Expression_ReferenceSegment_MapKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_ReferenceSegment_MapKey *>(to)->MergeFrom(
+      static_cast<const Expression_ReferenceSegment_MapKey &>(from));
+}
+
+
+void Expression_ReferenceSegment_MapKey::MergeFrom(const Expression_ReferenceSegment_MapKey& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment.MapKey)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_map_key()) {
+    _internal_mutable_map_key()->::substrait::Expression_Literal::MergeFrom(from._internal_map_key());
+  }
+  if (from._internal_has_child()) {
+    _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_ReferenceSegment_MapKey::CopyFrom(const Expression_ReferenceSegment_MapKey& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ReferenceSegment.MapKey)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_ReferenceSegment_MapKey::IsInitialized() const {
+  return true;
+}
+
+void Expression_ReferenceSegment_MapKey::InternalSwap(Expression_ReferenceSegment_MapKey* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_MapKey, child_)
+      + sizeof(Expression_ReferenceSegment_MapKey::child_)
+      - PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_MapKey, map_key_)>(
+          reinterpret_cast<char*>(&map_key_),
+          reinterpret_cast<char*>(&other->map_key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_MapKey::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[29]);
+}
+
+// ===================================================================
+
+class Expression_ReferenceSegment_StructField::_Internal {
+ public:
+  static const ::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_StructField* msg);
+};
+
+const ::substrait::Expression_ReferenceSegment&
+Expression_ReferenceSegment_StructField::_Internal::child(const Expression_ReferenceSegment_StructField* msg) {
+  return *msg->child_;
+}
+Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment.StructField)
+}
+Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(const Expression_ReferenceSegment_StructField& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_child()) {
+    child_ = new ::substrait::Expression_ReferenceSegment(*from.child_);
+  } else {
+    child_ = nullptr;
+  }
+  field_ = from.field_;
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.StructField)
+}
+
+inline void Expression_ReferenceSegment_StructField::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&child_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&field_) -
+    reinterpret_cast<char*>(&child_)) + sizeof(field_));
+}
+
+Expression_ReferenceSegment_StructField::~Expression_ReferenceSegment_StructField() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment.StructField)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_ReferenceSegment_StructField::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete child_;
+}
+
+void Expression_ReferenceSegment_StructField::ArenaDtor(void* object) {
+  Expression_ReferenceSegment_StructField* _this = reinterpret_cast< Expression_ReferenceSegment_StructField* >(object);
+  (void)_this;
+}
+void Expression_ReferenceSegment_StructField::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_ReferenceSegment_StructField::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_ReferenceSegment_StructField::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment.StructField)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && child_ != nullptr) {
+    delete child_;
+  }
+  child_ = nullptr;
+  field_ = 0;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_ReferenceSegment_StructField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 field = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.ReferenceSegment child = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_child(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_ReferenceSegment_StructField::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.StructField)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 field = 1;
+  if (this->_internal_field() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target);
+  }
+
+  // .substrait.Expression.ReferenceSegment child = 2;
+  if (this->_internal_has_child()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::child(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ReferenceSegment.StructField)
+  return target;
+}
+
+size_t Expression_ReferenceSegment_StructField::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.StructField)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Expression.ReferenceSegment child = 2;
+  if (this->_internal_has_child()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *child_);
+  }
+
+  // int32 field = 1;
+  if (this->_internal_field() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_field());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ReferenceSegment_StructField::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_ReferenceSegment_StructField::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ReferenceSegment_StructField::GetClassData() const { return &_class_data_; }
+
+void Expression_ReferenceSegment_StructField::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_ReferenceSegment_StructField *>(to)->MergeFrom(
+      static_cast<const Expression_ReferenceSegment_StructField &>(from));
+}
+
+
+void Expression_ReferenceSegment_StructField::MergeFrom(const Expression_ReferenceSegment_StructField& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment.StructField)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_child()) {
+    _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child());
+  }
+  if (from._internal_field() != 0) {
+    _internal_set_field(from._internal_field());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_ReferenceSegment_StructField::CopyFrom(const Expression_ReferenceSegment_StructField& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ReferenceSegment.StructField)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_ReferenceSegment_StructField::IsInitialized() const {
+  return true;
+}
+
+void Expression_ReferenceSegment_StructField::InternalSwap(Expression_ReferenceSegment_StructField* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_StructField, field_)
+      + sizeof(Expression_ReferenceSegment_StructField::field_)
+      - PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_StructField, child_)>(
+          reinterpret_cast<char*>(&child_),
+          reinterpret_cast<char*>(&other->child_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_StructField::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[30]);
+}
+
+// ===================================================================
+
+class Expression_ReferenceSegment_ListElement::_Internal {
+ public:
+  static const ::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_ListElement* msg);
+};
+
+const ::substrait::Expression_ReferenceSegment&
+Expression_ReferenceSegment_ListElement::_Internal::child(const Expression_ReferenceSegment_ListElement* msg) {
+  return *msg->child_;
+}
+Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment.ListElement)
+}
+Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(const Expression_ReferenceSegment_ListElement& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_child()) {
+    child_ = new ::substrait::Expression_ReferenceSegment(*from.child_);
+  } else {
+    child_ = nullptr;
+  }
+  offset_ = from.offset_;
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.ListElement)
+}
+
+inline void Expression_ReferenceSegment_ListElement::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&child_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&offset_) -
+    reinterpret_cast<char*>(&child_)) + sizeof(offset_));
+}
+
+Expression_ReferenceSegment_ListElement::~Expression_ReferenceSegment_ListElement() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment.ListElement)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_ReferenceSegment_ListElement::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete child_;
+}
+
+void Expression_ReferenceSegment_ListElement::ArenaDtor(void* object) {
+  Expression_ReferenceSegment_ListElement* _this = reinterpret_cast< Expression_ReferenceSegment_ListElement* >(object);
+  (void)_this;
+}
+void Expression_ReferenceSegment_ListElement::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_ReferenceSegment_ListElement::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_ReferenceSegment_ListElement::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment.ListElement)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && child_ != nullptr) {
+    delete child_;
+  }
+  child_ = nullptr;
+  offset_ = 0;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_ReferenceSegment_ListElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 offset = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.ReferenceSegment child = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_child(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_ReferenceSegment_ListElement::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.ListElement)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 offset = 1;
+  if (this->_internal_offset() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_offset(), target);
+  }
+
+  // .substrait.Expression.ReferenceSegment child = 2;
+  if (this->_internal_has_child()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::child(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ReferenceSegment.ListElement)
+  return target;
+}
+
+size_t Expression_ReferenceSegment_ListElement::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.ListElement)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Expression.ReferenceSegment child = 2;
+  if (this->_internal_has_child()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *child_);
+  }
+
+  // int32 offset = 1;
+  if (this->_internal_offset() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_offset());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ReferenceSegment_ListElement::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_ReferenceSegment_ListElement::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ReferenceSegment_ListElement::GetClassData() const { return &_class_data_; }
+
+void Expression_ReferenceSegment_ListElement::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_ReferenceSegment_ListElement *>(to)->MergeFrom(
+      static_cast<const Expression_ReferenceSegment_ListElement &>(from));
+}
+
+
+void Expression_ReferenceSegment_ListElement::MergeFrom(const Expression_ReferenceSegment_ListElement& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment.ListElement)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_child()) {
+    _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child());
+  }
+  if (from._internal_offset() != 0) {
+    _internal_set_offset(from._internal_offset());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_ReferenceSegment_ListElement::CopyFrom(const Expression_ReferenceSegment_ListElement& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ReferenceSegment.ListElement)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_ReferenceSegment_ListElement::IsInitialized() const {
+  return true;
+}
+
+void Expression_ReferenceSegment_ListElement::InternalSwap(Expression_ReferenceSegment_ListElement* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_ListElement, offset_)
+      + sizeof(Expression_ReferenceSegment_ListElement::offset_)
+      - PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_ListElement, child_)>(
+          reinterpret_cast<char*>(&child_),
+          reinterpret_cast<char*>(&other->child_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_ListElement::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[31]);
+}
+
+// ===================================================================
+
+class Expression_ReferenceSegment::_Internal {
+ public:
+  static const ::substrait::Expression_ReferenceSegment_MapKey& map_key(const Expression_ReferenceSegment* msg);
+  static const ::substrait::Expression_ReferenceSegment_StructField& struct_field(const Expression_ReferenceSegment* msg);
+  static const ::substrait::Expression_ReferenceSegment_ListElement& list_element(const Expression_ReferenceSegment* msg);
+};
+
+const ::substrait::Expression_ReferenceSegment_MapKey&
+Expression_ReferenceSegment::_Internal::map_key(const Expression_ReferenceSegment* msg) {
+  return *msg->reference_type_.map_key_;
+}
+const ::substrait::Expression_ReferenceSegment_StructField&
+Expression_ReferenceSegment::_Internal::struct_field(const Expression_ReferenceSegment* msg) {
+  return *msg->reference_type_.struct_field_;
+}
+const ::substrait::Expression_ReferenceSegment_ListElement&
+Expression_ReferenceSegment::_Internal::list_element(const Expression_ReferenceSegment* msg) {
+  return *msg->reference_type_.list_element_;
+}
+void Expression_ReferenceSegment::set_allocated_map_key(::substrait::Expression_ReferenceSegment_MapKey* map_key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_reference_type();
+  if (map_key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment_MapKey>::GetOwningArena(map_key);
+    if (message_arena != submessage_arena) {
+      map_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, map_key, submessage_arena);
+    }
+    set_has_map_key();
+    reference_type_.map_key_ = map_key;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.map_key)
+}
+void Expression_ReferenceSegment::set_allocated_struct_field(::substrait::Expression_ReferenceSegment_StructField* struct_field) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_reference_type();
+  if (struct_field) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment_StructField>::GetOwningArena(struct_field);
+    if (message_arena != submessage_arena) {
+      struct_field = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, struct_field, submessage_arena);
+    }
+    set_has_struct_field();
+    reference_type_.struct_field_ = struct_field;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.struct_field)
+}
+void Expression_ReferenceSegment::set_allocated_list_element(::substrait::Expression_ReferenceSegment_ListElement* list_element) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_reference_type();
+  if (list_element) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment_ListElement>::GetOwningArena(list_element);
+    if (message_arena != submessage_arena) {
+      list_element = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, list_element, submessage_arena);
+    }
+    set_has_list_element();
+    reference_type_.list_element_ = list_element;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.list_element)
+}
+Expression_ReferenceSegment::Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment)
+}
+Expression_ReferenceSegment::Expression_ReferenceSegment(const Expression_ReferenceSegment& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_reference_type();
+  switch (from.reference_type_case()) {
+    case kMapKey: {
+      _internal_mutable_map_key()->::substrait::Expression_ReferenceSegment_MapKey::MergeFrom(from._internal_map_key());
+      break;
+    }
+    case kStructField: {
+      _internal_mutable_struct_field()->::substrait::Expression_ReferenceSegment_StructField::MergeFrom(from._internal_struct_field());
+      break;
+    }
+    case kListElement: {
+      _internal_mutable_list_element()->::substrait::Expression_ReferenceSegment_ListElement::MergeFrom(from._internal_list_element());
+      break;
+    }
+    case REFERENCE_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment)
+}
+
+inline void Expression_ReferenceSegment::SharedCtor() {
+clear_has_reference_type();
+}
+
+Expression_ReferenceSegment::~Expression_ReferenceSegment() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_ReferenceSegment::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_reference_type()) {
+    clear_reference_type();
+  }
+}
+
+void Expression_ReferenceSegment::ArenaDtor(void* object) {
+  Expression_ReferenceSegment* _this = reinterpret_cast< Expression_ReferenceSegment* >(object);
+  (void)_this;
+}
+void Expression_ReferenceSegment::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_ReferenceSegment::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_ReferenceSegment::clear_reference_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.ReferenceSegment)
+  switch (reference_type_case()) {
+    case kMapKey: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete reference_type_.map_key_;
+      }
+      break;
+    }
+    case kStructField: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete reference_type_.struct_field_;
+      }
+      break;
+    }
+    case kListElement: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete reference_type_.list_element_;
+      }
+      break;
+    }
+    case REFERENCE_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = REFERENCE_TYPE_NOT_SET;
+}
+
+
+void Expression_ReferenceSegment::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_reference_type();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_ReferenceSegment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression.ReferenceSegment.MapKey map_key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.ReferenceSegment.StructField struct_field = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_struct_field(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.ReferenceSegment.ListElement list_element = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_list_element(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_ReferenceSegment::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression.ReferenceSegment.MapKey map_key = 1;
+  if (_internal_has_map_key()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::map_key(this), target, stream);
+  }
+
+  // .substrait.Expression.ReferenceSegment.StructField struct_field = 2;
+  if (_internal_has_struct_field()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::struct_field(this), target, stream);
+  }
+
+  // .substrait.Expression.ReferenceSegment.ListElement list_element = 3;
+  if (_internal_has_list_element()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::list_element(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ReferenceSegment)
+  return target;
+}
+
+size_t Expression_ReferenceSegment::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (reference_type_case()) {
+    // .substrait.Expression.ReferenceSegment.MapKey map_key = 1;
+    case kMapKey: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *reference_type_.map_key_);
+      break;
+    }
+    // .substrait.Expression.ReferenceSegment.StructField struct_field = 2;
+    case kStructField: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *reference_type_.struct_field_);
+      break;
+    }
+    // .substrait.Expression.ReferenceSegment.ListElement list_element = 3;
+    case kListElement: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *reference_type_.list_element_);
+      break;
+    }
+    case REFERENCE_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ReferenceSegment::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_ReferenceSegment::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ReferenceSegment::GetClassData() const { return &_class_data_; }
+
+void Expression_ReferenceSegment::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_ReferenceSegment *>(to)->MergeFrom(
+      static_cast<const Expression_ReferenceSegment &>(from));
+}
+
+
+void Expression_ReferenceSegment::MergeFrom(const Expression_ReferenceSegment& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.reference_type_case()) {
+    case kMapKey: {
+      _internal_mutable_map_key()->::substrait::Expression_ReferenceSegment_MapKey::MergeFrom(from._internal_map_key());
+      break;
+    }
+    case kStructField: {
+      _internal_mutable_struct_field()->::substrait::Expression_ReferenceSegment_StructField::MergeFrom(from._internal_struct_field());
+      break;
+    }
+    case kListElement: {
+      _internal_mutable_list_element()->::substrait::Expression_ReferenceSegment_ListElement::MergeFrom(from._internal_list_element());
+      break;
+    }
+    case REFERENCE_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_ReferenceSegment::CopyFrom(const Expression_ReferenceSegment& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ReferenceSegment)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_ReferenceSegment::IsInitialized() const {
+  return true;
+}
+
+void Expression_ReferenceSegment::InternalSwap(Expression_ReferenceSegment* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(reference_type_, other->reference_type_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[32]);
+}
+
+// ===================================================================
+
+class Expression_MaskExpression_Select::_Internal {
+ public:
+  static const ::substrait::Expression_MaskExpression_StructSelect& struct_(const Expression_MaskExpression_Select* msg);
+  static const ::substrait::Expression_MaskExpression_ListSelect& list(const Expression_MaskExpression_Select* msg);
+  static const ::substrait::Expression_MaskExpression_MapSelect& map(const Expression_MaskExpression_Select* msg);
+};
+
+const ::substrait::Expression_MaskExpression_StructSelect&
+Expression_MaskExpression_Select::_Internal::struct_(const Expression_MaskExpression_Select* msg) {
+  return *msg->type_.struct__;
+}
+const ::substrait::Expression_MaskExpression_ListSelect&
+Expression_MaskExpression_Select::_Internal::list(const Expression_MaskExpression_Select* msg) {
+  return *msg->type_.list_;
+}
+const ::substrait::Expression_MaskExpression_MapSelect&
+Expression_MaskExpression_Select::_Internal::map(const Expression_MaskExpression_Select* msg) {
+  return *msg->type_.map_;
+}
+void Expression_MaskExpression_Select::set_allocated_struct_(::substrait::Expression_MaskExpression_StructSelect* struct_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_type();
+  if (struct_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_StructSelect>::GetOwningArena(struct_);
+    if (message_arena != submessage_arena) {
+      struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, struct_, submessage_arena);
+    }
+    set_has_struct_();
+    type_.struct__ = struct_;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.struct)
+}
+void Expression_MaskExpression_Select::set_allocated_list(::substrait::Expression_MaskExpression_ListSelect* list) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_type();
+  if (list) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_ListSelect>::GetOwningArena(list);
+    if (message_arena != submessage_arena) {
+      list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, list, submessage_arena);
+    }
+    set_has_list();
+    type_.list_ = list;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.list)
+}
+void Expression_MaskExpression_Select::set_allocated_map(::substrait::Expression_MaskExpression_MapSelect* map) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_type();
+  if (map) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_MapSelect>::GetOwningArena(map);
+    if (message_arena != submessage_arena) {
+      map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, map, submessage_arena);
+    }
+    set_has_map();
+    type_.map_ = map;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.map)
+}
+Expression_MaskExpression_Select::Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.Select)
+}
+Expression_MaskExpression_Select::Expression_MaskExpression_Select(const Expression_MaskExpression_Select& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_type();
+  switch (from.type_case()) {
+    case kStruct: {
+      _internal_mutable_struct_()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_struct_());
+      break;
+    }
+    case kList: {
+      _internal_mutable_list()->::substrait::Expression_MaskExpression_ListSelect::MergeFrom(from._internal_list());
+      break;
+    }
+    case kMap: {
+      _internal_mutable_map()->::substrait::Expression_MaskExpression_MapSelect::MergeFrom(from._internal_map());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.Select)
+}
+
+inline void Expression_MaskExpression_Select::SharedCtor() {
+clear_has_type();
+}
+
+Expression_MaskExpression_Select::~Expression_MaskExpression_Select() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.Select)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MaskExpression_Select::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_type()) {
+    clear_type();
+  }
+}
+
+void Expression_MaskExpression_Select::ArenaDtor(void* object) {
+  Expression_MaskExpression_Select* _this = reinterpret_cast< Expression_MaskExpression_Select* >(object);
+  (void)_this;
+}
+void Expression_MaskExpression_Select::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MaskExpression_Select::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MaskExpression_Select::clear_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.Select)
+  switch (type_case()) {
+    case kStruct: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete type_.struct__;
+      }
+      break;
+    }
+    case kList: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete type_.list_;
+      }
+      break;
+    }
+    case kMap: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete type_.map_;
+      }
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+
+
+void Expression_MaskExpression_Select::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.Select)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_type();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MaskExpression_Select::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression.MaskExpression.StructSelect struct = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.MaskExpression.ListSelect list = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_list(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.MaskExpression.MapSelect map = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_map(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MaskExpression_Select::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.Select)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression.MaskExpression.StructSelect struct = 1;
+  if (_internal_has_struct_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::struct_(this), target, stream);
+  }
+
+  // .substrait.Expression.MaskExpression.ListSelect list = 2;
+  if (_internal_has_list()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::list(this), target, stream);
+  }
+
+  // .substrait.Expression.MaskExpression.MapSelect map = 3;
+  if (_internal_has_map()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::map(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.Select)
+  return target;
+}
+
+size_t Expression_MaskExpression_Select::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.Select)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (type_case()) {
+    // .substrait.Expression.MaskExpression.StructSelect struct = 1;
+    case kStruct: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *type_.struct__);
+      break;
+    }
+    // .substrait.Expression.MaskExpression.ListSelect list = 2;
+    case kList: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *type_.list_);
+      break;
+    }
+    // .substrait.Expression.MaskExpression.MapSelect map = 3;
+    case kMap: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *type_.map_);
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_Select::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MaskExpression_Select::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_Select::GetClassData() const { return &_class_data_; }
+
+void Expression_MaskExpression_Select::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MaskExpression_Select *>(to)->MergeFrom(
+      static_cast<const Expression_MaskExpression_Select &>(from));
+}
+
+
+void Expression_MaskExpression_Select::MergeFrom(const Expression_MaskExpression_Select& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.Select)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.type_case()) {
+    case kStruct: {
+      _internal_mutable_struct_()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_struct_());
+      break;
+    }
+    case kList: {
+      _internal_mutable_list()->::substrait::Expression_MaskExpression_ListSelect::MergeFrom(from._internal_list());
+      break;
+    }
+    case kMap: {
+      _internal_mutable_map()->::substrait::Expression_MaskExpression_MapSelect::MergeFrom(from._internal_map());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MaskExpression_Select::CopyFrom(const Expression_MaskExpression_Select& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.Select)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MaskExpression_Select::IsInitialized() const {
+  return true;
+}
+
+void Expression_MaskExpression_Select::InternalSwap(Expression_MaskExpression_Select* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(type_, other->type_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_Select::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[33]);
+}
+
+// ===================================================================
+
+class Expression_MaskExpression_StructSelect::_Internal {
+ public:
+};
+
+Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  struct_items_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.StructSelect)
+}
+Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(const Expression_MaskExpression_StructSelect& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      struct_items_(from.struct_items_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.StructSelect)
+}
+
+inline void Expression_MaskExpression_StructSelect::SharedCtor() {
+}
+
+Expression_MaskExpression_StructSelect::~Expression_MaskExpression_StructSelect() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.StructSelect)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MaskExpression_StructSelect::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Expression_MaskExpression_StructSelect::ArenaDtor(void* object) {
+  Expression_MaskExpression_StructSelect* _this = reinterpret_cast< Expression_MaskExpression_StructSelect* >(object);
+  (void)_this;
+}
+void Expression_MaskExpression_StructSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MaskExpression_StructSelect::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MaskExpression_StructSelect::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.StructSelect)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  struct_items_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MaskExpression_StructSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_struct_items(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MaskExpression_StructSelect::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.StructSelect)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_struct_items_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_struct_items(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.StructSelect)
+  return target;
+}
+
+size_t Expression_MaskExpression_StructSelect::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.StructSelect)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1;
+  total_size += 1UL * this->_internal_struct_items_size();
+  for (const auto& msg : this->struct_items_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_StructSelect::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MaskExpression_StructSelect::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_StructSelect::GetClassData() const { return &_class_data_; }
+
+void Expression_MaskExpression_StructSelect::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MaskExpression_StructSelect *>(to)->MergeFrom(
+      static_cast<const Expression_MaskExpression_StructSelect &>(from));
+}
+
+
+void Expression_MaskExpression_StructSelect::MergeFrom(const Expression_MaskExpression_StructSelect& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.StructSelect)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  struct_items_.MergeFrom(from.struct_items_);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MaskExpression_StructSelect::CopyFrom(const Expression_MaskExpression_StructSelect& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.StructSelect)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MaskExpression_StructSelect::IsInitialized() const {
+  return true;
+}
+
+void Expression_MaskExpression_StructSelect::InternalSwap(Expression_MaskExpression_StructSelect* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  struct_items_.InternalSwap(&other->struct_items_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_StructSelect::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[34]);
+}
+
+// ===================================================================
+
+class Expression_MaskExpression_StructItem::_Internal {
+ public:
+  static const ::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_StructItem* msg);
+};
+
+const ::substrait::Expression_MaskExpression_Select&
+Expression_MaskExpression_StructItem::_Internal::child(const Expression_MaskExpression_StructItem* msg) {
+  return *msg->child_;
+}
+Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.StructItem)
+}
+Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(const Expression_MaskExpression_StructItem& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_child()) {
+    child_ = new ::substrait::Expression_MaskExpression_Select(*from.child_);
+  } else {
+    child_ = nullptr;
+  }
+  field_ = from.field_;
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.StructItem)
+}
+
+inline void Expression_MaskExpression_StructItem::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&child_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&field_) -
+    reinterpret_cast<char*>(&child_)) + sizeof(field_));
+}
+
+Expression_MaskExpression_StructItem::~Expression_MaskExpression_StructItem() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.StructItem)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MaskExpression_StructItem::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete child_;
+}
+
+void Expression_MaskExpression_StructItem::ArenaDtor(void* object) {
+  Expression_MaskExpression_StructItem* _this = reinterpret_cast< Expression_MaskExpression_StructItem* >(object);
+  (void)_this;
+}
+void Expression_MaskExpression_StructItem::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MaskExpression_StructItem::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MaskExpression_StructItem::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.StructItem)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && child_ != nullptr) {
+    delete child_;
+  }
+  child_ = nullptr;
+  field_ = 0;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MaskExpression_StructItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 field = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.MaskExpression.Select child = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_child(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MaskExpression_StructItem::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.StructItem)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 field = 1;
+  if (this->_internal_field() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target);
+  }
+
+  // .substrait.Expression.MaskExpression.Select child = 2;
+  if (this->_internal_has_child()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::child(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.StructItem)
+  return target;
+}
+
+size_t Expression_MaskExpression_StructItem::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.StructItem)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Expression.MaskExpression.Select child = 2;
+  if (this->_internal_has_child()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *child_);
+  }
+
+  // int32 field = 1;
+  if (this->_internal_field() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_field());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_StructItem::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MaskExpression_StructItem::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_StructItem::GetClassData() const { return &_class_data_; }
+
+void Expression_MaskExpression_StructItem::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MaskExpression_StructItem *>(to)->MergeFrom(
+      static_cast<const Expression_MaskExpression_StructItem &>(from));
+}
+
+
+void Expression_MaskExpression_StructItem::MergeFrom(const Expression_MaskExpression_StructItem& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.StructItem)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_child()) {
+    _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child());
+  }
+  if (from._internal_field() != 0) {
+    _internal_set_field(from._internal_field());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MaskExpression_StructItem::CopyFrom(const Expression_MaskExpression_StructItem& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.StructItem)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MaskExpression_StructItem::IsInitialized() const {
+  return true;
+}
+
+void Expression_MaskExpression_StructItem::InternalSwap(Expression_MaskExpression_StructItem* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_StructItem, field_)
+      + sizeof(Expression_MaskExpression_StructItem::field_)
+      - PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_StructItem, child_)>(
+          reinterpret_cast<char*>(&child_),
+          reinterpret_cast<char*>(&other->child_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_StructItem::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[35]);
+}
+
+// ===================================================================
+
+class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_Internal {
+ public:
+};
+
+Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
+}
+Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  field_ = from.field_;
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
+}
+
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SharedCtor() {
+field_ = 0;
+}
+
+Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::~Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::ArenaDtor(void* object) {
+  Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* _this = reinterpret_cast< Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* >(object);
+  (void)_this;
+}
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  field_ = 0;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 field = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 field = 1;
+  if (this->_internal_field() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
+  return target;
+}
+
+size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 field = 1;
+  if (this->_internal_field() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_field());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::GetClassData() const { return &_class_data_; }
+
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MaskExpression_ListSelect_ListSelectItem_ListElement *>(to)->MergeFrom(
+      static_cast<const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement &>(from));
+}
+
+
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_field() != 0) {
+    _internal_set_field(from._internal_field());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::IsInitialized() const {
+  return true;
+}
+
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(field_, other->field_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[36]);
+}
+
+// ===================================================================
+
+class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_Internal {
+ public:
+};
+
+Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
+}
+Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&start_, &from.start_,
+    static_cast<size_t>(reinterpret_cast<char*>(&end_) -
+    reinterpret_cast<char*>(&start_)) + sizeof(end_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
+}
+
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&start_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&end_) -
+    reinterpret_cast<char*>(&start_)) + sizeof(end_));
+}
+
+Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::~Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::ArenaDtor(void* object) {
+  Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* _this = reinterpret_cast< Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* >(object);
+  (void)_this;
+}
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&start_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&end_) -
+      reinterpret_cast<char*>(&start_)) + sizeof(end_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 start = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 end = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 start = 1;
+  if (this->_internal_start() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_start(), target);
+  }
+
+  // int32 end = 2;
+  if (this->_internal_end() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_end(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
+  return target;
+}
+
+size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 start = 1;
+  if (this->_internal_start() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_start());
+  }
+
+  // int32 end = 2;
+  if (this->_internal_end() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_end());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::GetClassData() const { return &_class_data_; }
+
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice *>(to)->MergeFrom(
+      static_cast<const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice &>(from));
+}
+
+
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_start() != 0) {
+    _internal_set_start(from._internal_start());
+  }
+  if (from._internal_end() != 0) {
+    _internal_set_end(from._internal_end());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::IsInitialized() const {
+  return true;
+}
+
+void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, end_)
+      + sizeof(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::end_)
+      - PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, start_)>(
+          reinterpret_cast<char*>(&start_),
+          reinterpret_cast<char*>(&other->start_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[37]);
+}
+
+// ===================================================================
+
+class Expression_MaskExpression_ListSelect_ListSelectItem::_Internal {
+ public:
+  static const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& item(const Expression_MaskExpression_ListSelect_ListSelectItem* msg);
+  static const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& slice(const Expression_MaskExpression_ListSelect_ListSelectItem* msg);
+};
+
+const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&
+Expression_MaskExpression_ListSelect_ListSelectItem::_Internal::item(const Expression_MaskExpression_ListSelect_ListSelectItem* msg) {
+  return *msg->type_.item_;
+}
+const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&
+Expression_MaskExpression_ListSelect_ListSelectItem::_Internal::slice(const Expression_MaskExpression_ListSelect_ListSelectItem* msg) {
+  return *msg->type_.slice_;
+}
+void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_item(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_type();
+  if (item) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement>::GetOwningArena(item);
+    if (message_arena != submessage_arena) {
+      item = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, item, submessage_arena);
+    }
+    set_has_item();
+    type_.item_ = item;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item)
+}
+void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_slice(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_type();
+  if (slice) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice>::GetOwningArena(slice);
+    if (message_arena != submessage_arena) {
+      slice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, slice, submessage_arena);
+    }
+    set_has_slice();
+    type_.slice_ = slice;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice)
+}
+Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
+}
+Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(const Expression_MaskExpression_ListSelect_ListSelectItem& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_type();
+  switch (from.type_case()) {
+    case kItem: {
+      _internal_mutable_item()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item());
+      break;
+    }
+    case kSlice: {
+      _internal_mutable_slice()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
+}
+
+inline void Expression_MaskExpression_ListSelect_ListSelectItem::SharedCtor() {
+clear_has_type();
+}
+
+Expression_MaskExpression_ListSelect_ListSelectItem::~Expression_MaskExpression_ListSelect_ListSelectItem() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MaskExpression_ListSelect_ListSelectItem::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_type()) {
+    clear_type();
+  }
+}
+
+void Expression_MaskExpression_ListSelect_ListSelectItem::ArenaDtor(void* object) {
+  Expression_MaskExpression_ListSelect_ListSelectItem* _this = reinterpret_cast< Expression_MaskExpression_ListSelect_ListSelectItem* >(object);
+  (void)_this;
+}
+void Expression_MaskExpression_ListSelect_ListSelectItem::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MaskExpression_ListSelect_ListSelectItem::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MaskExpression_ListSelect_ListSelectItem::clear_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
+  switch (type_case()) {
+    case kItem: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete type_.item_;
+      }
+      break;
+    }
+    case kSlice: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete type_.slice_;
+      }
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+
+
+void Expression_MaskExpression_ListSelect_ListSelectItem::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_type();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_item(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_slice(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1;
+  if (_internal_has_item()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::item(this), target, stream);
+  }
+
+  // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2;
+  if (_internal_has_slice()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::slice(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
+  return target;
+}
+
+size_t Expression_MaskExpression_ListSelect_ListSelectItem::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (type_case()) {
+    // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1;
+    case kItem: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *type_.item_);
+      break;
+    }
+    // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2;
+    case kSlice: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *type_.slice_);
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_ListSelect_ListSelectItem::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MaskExpression_ListSelect_ListSelectItem::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_ListSelect_ListSelectItem::GetClassData() const { return &_class_data_; }
+
+void Expression_MaskExpression_ListSelect_ListSelectItem::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MaskExpression_ListSelect_ListSelectItem *>(to)->MergeFrom(
+      static_cast<const Expression_MaskExpression_ListSelect_ListSelectItem &>(from));
+}
+
+
+void Expression_MaskExpression_ListSelect_ListSelectItem::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.type_case()) {
+    case kItem: {
+      _internal_mutable_item()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item());
+      break;
+    }
+    case kSlice: {
+      _internal_mutable_slice()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MaskExpression_ListSelect_ListSelectItem::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MaskExpression_ListSelect_ListSelectItem::IsInitialized() const {
+  return true;
+}
+
+void Expression_MaskExpression_ListSelect_ListSelectItem::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(type_, other->type_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[38]);
+}
+
+// ===================================================================
+
+class Expression_MaskExpression_ListSelect::_Internal {
+ public:
+  static const ::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_ListSelect* msg);
+};
+
+const ::substrait::Expression_MaskExpression_Select&
+Expression_MaskExpression_ListSelect::_Internal::child(const Expression_MaskExpression_ListSelect* msg) {
+  return *msg->child_;
+}
+Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  selection_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect)
+}
+Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(const Expression_MaskExpression_ListSelect& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      selection_(from.selection_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_child()) {
+    child_ = new ::substrait::Expression_MaskExpression_Select(*from.child_);
+  } else {
+    child_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect)
+}
+
+inline void Expression_MaskExpression_ListSelect::SharedCtor() {
+child_ = nullptr;
+}
+
+Expression_MaskExpression_ListSelect::~Expression_MaskExpression_ListSelect() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MaskExpression_ListSelect::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete child_;
+}
+
+void Expression_MaskExpression_ListSelect::ArenaDtor(void* object) {
+  Expression_MaskExpression_ListSelect* _this = reinterpret_cast< Expression_MaskExpression_ListSelect* >(object);
+  (void)_this;
+}
+void Expression_MaskExpression_ListSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MaskExpression_ListSelect::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MaskExpression_ListSelect::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  selection_.Clear();
+  if (GetArenaForAllocation() == nullptr && child_ != nullptr) {
+    delete child_;
+  }
+  child_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MaskExpression_ListSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_selection(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.MaskExpression.Select child = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_child(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MaskExpression_ListSelect::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_selection_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_selection(i), target, stream);
+  }
+
+  // .substrait.Expression.MaskExpression.Select child = 2;
+  if (this->_internal_has_child()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::child(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.ListSelect)
+  return target;
+}
+
+size_t Expression_MaskExpression_ListSelect::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1;
+  total_size += 1UL * this->_internal_selection_size();
+  for (const auto& msg : this->selection_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.Expression.MaskExpression.Select child = 2;
+  if (this->_internal_has_child()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *child_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_ListSelect::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MaskExpression_ListSelect::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_ListSelect::GetClassData() const { return &_class_data_; }
+
+void Expression_MaskExpression_ListSelect::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MaskExpression_ListSelect *>(to)->MergeFrom(
+      static_cast<const Expression_MaskExpression_ListSelect &>(from));
+}
+
+
+void Expression_MaskExpression_ListSelect::MergeFrom(const Expression_MaskExpression_ListSelect& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  selection_.MergeFrom(from.selection_);
+  if (from._internal_has_child()) {
+    _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MaskExpression_ListSelect::CopyFrom(const Expression_MaskExpression_ListSelect& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MaskExpression_ListSelect::IsInitialized() const {
+  return true;
+}
+
+void Expression_MaskExpression_ListSelect::InternalSwap(Expression_MaskExpression_ListSelect* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  selection_.InternalSwap(&other->selection_);
+  swap(child_, other->child_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[39]);
+}
+
+// ===================================================================
+
+class Expression_MaskExpression_MapSelect_MapKey::_Internal {
+ public:
+};
+
+Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.MapSelect.MapKey)
+}
+Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(const Expression_MaskExpression_MapSelect_MapKey& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    map_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_map_key().empty()) {
+    map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key(), 
+      GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect.MapKey)
+}
+
+inline void Expression_MaskExpression_MapSelect_MapKey::SharedCtor() {
+map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  map_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Expression_MaskExpression_MapSelect_MapKey::~Expression_MaskExpression_MapSelect_MapKey() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.MapSelect.MapKey)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MaskExpression_MapSelect_MapKey::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  map_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Expression_MaskExpression_MapSelect_MapKey::ArenaDtor(void* object) {
+  Expression_MaskExpression_MapSelect_MapKey* _this = reinterpret_cast< Expression_MaskExpression_MapSelect_MapKey* >(object);
+  (void)_this;
+}
+void Expression_MaskExpression_MapSelect_MapKey::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MaskExpression_MapSelect_MapKey::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MaskExpression_MapSelect_MapKey::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect.MapKey)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  map_key_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MaskExpression_MapSelect_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string map_key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_map_key();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.MaskExpression.MapSelect.MapKey.map_key"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MaskExpression_MapSelect_MapKey::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect.MapKey)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string map_key = 1;
+  if (!this->_internal_map_key().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_map_key().data(), static_cast<int>(this->_internal_map_key().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Expression.MaskExpression.MapSelect.MapKey.map_key");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_map_key(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.MapSelect.MapKey)
+  return target;
+}
+
+size_t Expression_MaskExpression_MapSelect_MapKey::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect.MapKey)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string map_key = 1;
+  if (!this->_internal_map_key().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_map_key());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_MapSelect_MapKey::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MaskExpression_MapSelect_MapKey::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_MapSelect_MapKey::GetClassData() const { return &_class_data_; }
+
+void Expression_MaskExpression_MapSelect_MapKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MaskExpression_MapSelect_MapKey *>(to)->MergeFrom(
+      static_cast<const Expression_MaskExpression_MapSelect_MapKey &>(from));
+}
+
+
+void Expression_MaskExpression_MapSelect_MapKey::MergeFrom(const Expression_MaskExpression_MapSelect_MapKey& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_map_key().empty()) {
+    _internal_set_map_key(from._internal_map_key());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MaskExpression_MapSelect_MapKey::CopyFrom(const Expression_MaskExpression_MapSelect_MapKey& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MaskExpression_MapSelect_MapKey::IsInitialized() const {
+  return true;
+}
+
+void Expression_MaskExpression_MapSelect_MapKey::InternalSwap(Expression_MaskExpression_MapSelect_MapKey* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &map_key_, lhs_arena,
+      &other->map_key_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect_MapKey::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[40]);
+}
+
+// ===================================================================
+
+class Expression_MaskExpression_MapSelect_MapKeyExpression::_Internal {
+ public:
+};
+
+Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
+}
+Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(const Expression_MaskExpression_MapSelect_MapKeyExpression& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    map_key_expression_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_map_key_expression().empty()) {
+    map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key_expression(), 
+      GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
+}
+
+inline void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedCtor() {
+map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  map_key_expression_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+Expression_MaskExpression_MapSelect_MapKeyExpression::~Expression_MaskExpression_MapSelect_MapKeyExpression() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  map_key_expression_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Expression_MaskExpression_MapSelect_MapKeyExpression::ArenaDtor(void* object) {
+  Expression_MaskExpression_MapSelect_MapKeyExpression* _this = reinterpret_cast< Expression_MaskExpression_MapSelect_MapKeyExpression* >(object);
+  (void)_this;
+}
+void Expression_MaskExpression_MapSelect_MapKeyExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MaskExpression_MapSelect_MapKeyExpression::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MaskExpression_MapSelect_MapKeyExpression::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  map_key_expression_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string map_key_expression = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_map_key_expression();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string map_key_expression = 1;
+  if (!this->_internal_map_key_expression().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_map_key_expression().data(), static_cast<int>(this->_internal_map_key_expression().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_map_key_expression(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
+  return target;
+}
+
+size_t Expression_MaskExpression_MapSelect_MapKeyExpression::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string map_key_expression = 1;
+  if (!this->_internal_map_key_expression().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_map_key_expression());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_MapSelect_MapKeyExpression::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MaskExpression_MapSelect_MapKeyExpression::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_MapSelect_MapKeyExpression::GetClassData() const { return &_class_data_; }
+
+void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MaskExpression_MapSelect_MapKeyExpression *>(to)->MergeFrom(
+      static_cast<const Expression_MaskExpression_MapSelect_MapKeyExpression &>(from));
+}
+
+
+void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_map_key_expression().empty()) {
+    _internal_set_map_key_expression(from._internal_map_key_expression());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MaskExpression_MapSelect_MapKeyExpression::IsInitialized() const {
+  return true;
+}
+
+void Expression_MaskExpression_MapSelect_MapKeyExpression::InternalSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &map_key_expression_, lhs_arena,
+      &other->map_key_expression_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect_MapKeyExpression::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[41]);
+}
+
+// ===================================================================
+
+class Expression_MaskExpression_MapSelect::_Internal {
+ public:
+  static const ::substrait::Expression_MaskExpression_MapSelect_MapKey& key(const Expression_MaskExpression_MapSelect* msg);
+  static const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& expression(const Expression_MaskExpression_MapSelect* msg);
+  static const ::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_MapSelect* msg);
+};
+
+const ::substrait::Expression_MaskExpression_MapSelect_MapKey&
+Expression_MaskExpression_MapSelect::_Internal::key(const Expression_MaskExpression_MapSelect* msg) {
+  return *msg->select_.key_;
+}
+const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression&
+Expression_MaskExpression_MapSelect::_Internal::expression(const Expression_MaskExpression_MapSelect* msg) {
+  return *msg->select_.expression_;
+}
+const ::substrait::Expression_MaskExpression_Select&
+Expression_MaskExpression_MapSelect::_Internal::child(const Expression_MaskExpression_MapSelect* msg) {
+  return *msg->child_;
+}
+void Expression_MaskExpression_MapSelect::set_allocated_key(::substrait::Expression_MaskExpression_MapSelect_MapKey* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_select();
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_MapSelect_MapKey>::GetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    set_has_key();
+    select_.key_ = key;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.key)
+}
+void Expression_MaskExpression_MapSelect::set_allocated_expression(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_select();
+  if (expression) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression>::GetOwningArena(expression);
+    if (message_arena != submessage_arena) {
+      expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, expression, submessage_arena);
+    }
+    set_has_expression();
+    select_.expression_ = expression;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.expression)
+}
+Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.MapSelect)
+}
+Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(const Expression_MaskExpression_MapSelect& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_child()) {
+    child_ = new ::substrait::Expression_MaskExpression_Select(*from.child_);
+  } else {
+    child_ = nullptr;
+  }
+  clear_has_select();
+  switch (from.select_case()) {
+    case kKey: {
+      _internal_mutable_key()->::substrait::Expression_MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key());
+      break;
+    }
+    case kExpression: {
+      _internal_mutable_expression()->::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression());
+      break;
+    }
+    case SELECT_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect)
+}
+
+inline void Expression_MaskExpression_MapSelect::SharedCtor() {
+child_ = nullptr;
+clear_has_select();
+}
+
+Expression_MaskExpression_MapSelect::~Expression_MaskExpression_MapSelect() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.MapSelect)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MaskExpression_MapSelect::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete child_;
+  if (has_select()) {
+    clear_select();
+  }
+}
+
+void Expression_MaskExpression_MapSelect::ArenaDtor(void* object) {
+  Expression_MaskExpression_MapSelect* _this = reinterpret_cast< Expression_MaskExpression_MapSelect* >(object);
+  (void)_this;
+}
+void Expression_MaskExpression_MapSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MaskExpression_MapSelect::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MaskExpression_MapSelect::clear_select() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.MapSelect)
+  switch (select_case()) {
+    case kKey: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete select_.key_;
+      }
+      break;
+    }
+    case kExpression: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete select_.expression_;
+      }
+      break;
+    }
+    case SELECT_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = SELECT_NOT_SET;
+}
+
+
+void Expression_MaskExpression_MapSelect::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && child_ != nullptr) {
+    delete child_;
+  }
+  child_ = nullptr;
+  clear_select();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MaskExpression_MapSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.MaskExpression.Select child = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_child(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MaskExpression_MapSelect::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1;
+  if (_internal_has_key()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::key(this), target, stream);
+  }
+
+  // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2;
+  if (_internal_has_expression()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::expression(this), target, stream);
+  }
+
+  // .substrait.Expression.MaskExpression.Select child = 3;
+  if (this->_internal_has_child()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::child(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.MapSelect)
+  return target;
+}
+
+size_t Expression_MaskExpression_MapSelect::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Expression.MaskExpression.Select child = 3;
+  if (this->_internal_has_child()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *child_);
+  }
+
+  switch (select_case()) {
+    // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1;
+    case kKey: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *select_.key_);
+      break;
+    }
+    // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2;
+    case kExpression: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *select_.expression_);
+      break;
+    }
+    case SELECT_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_MapSelect::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MaskExpression_MapSelect::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_MapSelect::GetClassData() const { return &_class_data_; }
+
+void Expression_MaskExpression_MapSelect::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MaskExpression_MapSelect *>(to)->MergeFrom(
+      static_cast<const Expression_MaskExpression_MapSelect &>(from));
+}
+
+
+void Expression_MaskExpression_MapSelect::MergeFrom(const Expression_MaskExpression_MapSelect& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_child()) {
+    _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child());
+  }
+  switch (from.select_case()) {
+    case kKey: {
+      _internal_mutable_key()->::substrait::Expression_MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key());
+      break;
+    }
+    case kExpression: {
+      _internal_mutable_expression()->::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression());
+      break;
+    }
+    case SELECT_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MaskExpression_MapSelect::CopyFrom(const Expression_MaskExpression_MapSelect& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.MapSelect)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MaskExpression_MapSelect::IsInitialized() const {
+  return true;
+}
+
+void Expression_MaskExpression_MapSelect::InternalSwap(Expression_MaskExpression_MapSelect* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(child_, other->child_);
+  swap(select_, other->select_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[42]);
+}
+
+// ===================================================================
+
+class Expression_MaskExpression::_Internal {
+ public:
+  static const ::substrait::Expression_MaskExpression_StructSelect& select(const Expression_MaskExpression* msg);
+};
+
+const ::substrait::Expression_MaskExpression_StructSelect&
+Expression_MaskExpression::_Internal::select(const Expression_MaskExpression* msg) {
+  return *msg->select_;
+}
+Expression_MaskExpression::Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression)
+}
+Expression_MaskExpression::Expression_MaskExpression(const Expression_MaskExpression& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_select()) {
+    select_ = new ::substrait::Expression_MaskExpression_StructSelect(*from.select_);
+  } else {
+    select_ = nullptr;
+  }
+  maintain_singular_struct_ = from.maintain_singular_struct_;
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression)
+}
+
+inline void Expression_MaskExpression::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&select_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&maintain_singular_struct_) -
+    reinterpret_cast<char*>(&select_)) + sizeof(maintain_singular_struct_));
+}
+
+Expression_MaskExpression::~Expression_MaskExpression() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_MaskExpression::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete select_;
+}
+
+void Expression_MaskExpression::ArenaDtor(void* object) {
+  Expression_MaskExpression* _this = reinterpret_cast< Expression_MaskExpression* >(object);
+  (void)_this;
+}
+void Expression_MaskExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_MaskExpression::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_MaskExpression::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && select_ != nullptr) {
+    delete select_;
+  }
+  select_ = nullptr;
+  maintain_singular_struct_ = false;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_MaskExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression.MaskExpression.StructSelect select = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_select(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool maintain_singular_struct = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          maintain_singular_struct_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_MaskExpression::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression.MaskExpression.StructSelect select = 1;
+  if (this->_internal_has_select()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::select(this), target, stream);
+  }
+
+  // bool maintain_singular_struct = 2;
+  if (this->_internal_maintain_singular_struct() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_maintain_singular_struct(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression)
+  return target;
+}
+
+size_t Expression_MaskExpression::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Expression.MaskExpression.StructSelect select = 1;
+  if (this->_internal_has_select()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *select_);
+  }
+
+  // bool maintain_singular_struct = 2;
+  if (this->_internal_maintain_singular_struct() != 0) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_MaskExpression::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression::GetClassData() const { return &_class_data_; }
+
+void Expression_MaskExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_MaskExpression *>(to)->MergeFrom(
+      static_cast<const Expression_MaskExpression &>(from));
+}
+
+
+void Expression_MaskExpression::MergeFrom(const Expression_MaskExpression& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_select()) {
+    _internal_mutable_select()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_select());
+  }
+  if (from._internal_maintain_singular_struct() != 0) {
+    _internal_set_maintain_singular_struct(from._internal_maintain_singular_struct());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_MaskExpression::CopyFrom(const Expression_MaskExpression& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_MaskExpression::IsInitialized() const {
+  return true;
+}
+
+void Expression_MaskExpression::InternalSwap(Expression_MaskExpression* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Expression_MaskExpression, maintain_singular_struct_)
+      + sizeof(Expression_MaskExpression::maintain_singular_struct_)
+      - PROTOBUF_FIELD_OFFSET(Expression_MaskExpression, select_)>(
+          reinterpret_cast<char*>(&select_),
+          reinterpret_cast<char*>(&other->select_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[43]);
+}
+
+// ===================================================================
+
+class Expression_FieldReference_RootReference::_Internal {
+ public:
+};
+
+Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.FieldReference.RootReference)
+}
+Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(const Expression_FieldReference_RootReference& from)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.FieldReference.RootReference)
+}
+
+
+
+
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_FieldReference_RootReference::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_FieldReference_RootReference::GetClassData() const { return &_class_data_; }
+
+
+
+
+
+
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_FieldReference_RootReference::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[44]);
+}
+
+// ===================================================================
+
+class Expression_FieldReference::_Internal {
+ public:
+  static const ::substrait::Expression_ReferenceSegment& direct_reference(const Expression_FieldReference* msg);
+  static const ::substrait::Expression_MaskExpression& masked_reference(const Expression_FieldReference* msg);
+  static const ::substrait::Expression& expression(const Expression_FieldReference* msg);
+  static const ::substrait::Expression_FieldReference_RootReference& root_reference(const Expression_FieldReference* msg);
+};
+
+const ::substrait::Expression_ReferenceSegment&
+Expression_FieldReference::_Internal::direct_reference(const Expression_FieldReference* msg) {
+  return *msg->reference_type_.direct_reference_;
+}
+const ::substrait::Expression_MaskExpression&
+Expression_FieldReference::_Internal::masked_reference(const Expression_FieldReference* msg) {
+  return *msg->reference_type_.masked_reference_;
+}
+const ::substrait::Expression&
+Expression_FieldReference::_Internal::expression(const Expression_FieldReference* msg) {
+  return *msg->root_type_.expression_;
+}
+const ::substrait::Expression_FieldReference_RootReference&
+Expression_FieldReference::_Internal::root_reference(const Expression_FieldReference* msg) {
+  return *msg->root_type_.root_reference_;
+}
+void Expression_FieldReference::set_allocated_direct_reference(::substrait::Expression_ReferenceSegment* direct_reference) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_reference_type();
+  if (direct_reference) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(direct_reference);
+    if (message_arena != submessage_arena) {
+      direct_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, direct_reference, submessage_arena);
+    }
+    set_has_direct_reference();
+    reference_type_.direct_reference_ = direct_reference;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.direct_reference)
+}
+void Expression_FieldReference::set_allocated_masked_reference(::substrait::Expression_MaskExpression* masked_reference) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_reference_type();
+  if (masked_reference) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression>::GetOwningArena(masked_reference);
+    if (message_arena != submessage_arena) {
+      masked_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, masked_reference, submessage_arena);
+    }
+    set_has_masked_reference();
+    reference_type_.masked_reference_ = masked_reference;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.masked_reference)
+}
+void Expression_FieldReference::set_allocated_expression(::substrait::Expression* expression) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_root_type();
+  if (expression) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(expression);
+    if (message_arena != submessage_arena) {
+      expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, expression, submessage_arena);
+    }
+    set_has_expression();
+    root_type_.expression_ = expression;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.expression)
+}
+void Expression_FieldReference::set_allocated_root_reference(::substrait::Expression_FieldReference_RootReference* root_reference) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_root_type();
+  if (root_reference) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_FieldReference_RootReference>::GetOwningArena(root_reference);
+    if (message_arena != submessage_arena) {
+      root_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, root_reference, submessage_arena);
+    }
+    set_has_root_reference();
+    root_type_.root_reference_ = root_reference;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.root_reference)
+}
+Expression_FieldReference::Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression.FieldReference)
+}
+Expression_FieldReference::Expression_FieldReference(const Expression_FieldReference& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_reference_type();
+  switch (from.reference_type_case()) {
+    case kDirectReference: {
+      _internal_mutable_direct_reference()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_direct_reference());
+      break;
+    }
+    case kMaskedReference: {
+      _internal_mutable_masked_reference()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_masked_reference());
+      break;
+    }
+    case REFERENCE_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  clear_has_root_type();
+  switch (from.root_type_case()) {
+    case kExpression: {
+      _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression());
+      break;
+    }
+    case kRootReference: {
+      _internal_mutable_root_reference()->::substrait::Expression_FieldReference_RootReference::MergeFrom(from._internal_root_reference());
+      break;
+    }
+    case ROOT_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression.FieldReference)
+}
+
+inline void Expression_FieldReference::SharedCtor() {
+clear_has_reference_type();
+clear_has_root_type();
+}
+
+Expression_FieldReference::~Expression_FieldReference() {
+  // @@protoc_insertion_point(destructor:substrait.Expression.FieldReference)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression_FieldReference::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_reference_type()) {
+    clear_reference_type();
+  }
+  if (has_root_type()) {
+    clear_root_type();
+  }
+}
+
+void Expression_FieldReference::ArenaDtor(void* object) {
+  Expression_FieldReference* _this = reinterpret_cast< Expression_FieldReference* >(object);
+  (void)_this;
+}
+void Expression_FieldReference::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression_FieldReference::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression_FieldReference::clear_reference_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.FieldReference)
+  switch (reference_type_case()) {
+    case kDirectReference: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete reference_type_.direct_reference_;
+      }
+      break;
+    }
+    case kMaskedReference: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete reference_type_.masked_reference_;
+      }
+      break;
+    }
+    case REFERENCE_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = REFERENCE_TYPE_NOT_SET;
+}
+
+void Expression_FieldReference::clear_root_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.FieldReference)
+  switch (root_type_case()) {
+    case kExpression: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete root_type_.expression_;
+      }
+      break;
+    }
+    case kRootReference: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete root_type_.root_reference_;
+      }
+      break;
+    }
+    case ROOT_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[1] = ROOT_TYPE_NOT_SET;
+}
+
+
+void Expression_FieldReference::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression.FieldReference)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_reference_type();
+  clear_root_type();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression_FieldReference::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression.ReferenceSegment direct_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_direct_reference(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.MaskExpression masked_reference = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_masked_reference(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression expression = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.FieldReference.RootReference root_reference = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_root_reference(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression_FieldReference::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.FieldReference)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression.ReferenceSegment direct_reference = 1;
+  if (_internal_has_direct_reference()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::direct_reference(this), target, stream);
+  }
+
+  // .substrait.Expression.MaskExpression masked_reference = 2;
+  if (_internal_has_masked_reference()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::masked_reference(this), target, stream);
+  }
+
+  // .substrait.Expression expression = 3;
+  if (_internal_has_expression()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::expression(this), target, stream);
+  }
+
+  // .substrait.Expression.FieldReference.RootReference root_reference = 4;
+  if (_internal_has_root_reference()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::root_reference(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.FieldReference)
+  return target;
+}
+
+size_t Expression_FieldReference::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.FieldReference)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (reference_type_case()) {
+    // .substrait.Expression.ReferenceSegment direct_reference = 1;
+    case kDirectReference: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *reference_type_.direct_reference_);
+      break;
+    }
+    // .substrait.Expression.MaskExpression masked_reference = 2;
+    case kMaskedReference: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *reference_type_.masked_reference_);
+      break;
+    }
+    case REFERENCE_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  switch (root_type_case()) {
+    // .substrait.Expression expression = 3;
+    case kExpression: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *root_type_.expression_);
+      break;
+    }
+    // .substrait.Expression.FieldReference.RootReference root_reference = 4;
+    case kRootReference: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *root_type_.root_reference_);
+      break;
+    }
+    case ROOT_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_FieldReference::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression_FieldReference::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_FieldReference::GetClassData() const { return &_class_data_; }
+
+void Expression_FieldReference::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression_FieldReference *>(to)->MergeFrom(
+      static_cast<const Expression_FieldReference &>(from));
+}
+
+
+void Expression_FieldReference::MergeFrom(const Expression_FieldReference& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.FieldReference)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.reference_type_case()) {
+    case kDirectReference: {
+      _internal_mutable_direct_reference()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_direct_reference());
+      break;
+    }
+    case kMaskedReference: {
+      _internal_mutable_masked_reference()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_masked_reference());
+      break;
+    }
+    case REFERENCE_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  switch (from.root_type_case()) {
+    case kExpression: {
+      _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression());
+      break;
+    }
+    case kRootReference: {
+      _internal_mutable_root_reference()->::substrait::Expression_FieldReference_RootReference::MergeFrom(from._internal_root_reference());
+      break;
+    }
+    case ROOT_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression_FieldReference::CopyFrom(const Expression_FieldReference& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.FieldReference)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression_FieldReference::IsInitialized() const {
+  return true;
+}
+
+void Expression_FieldReference::InternalSwap(Expression_FieldReference* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(reference_type_, other->reference_type_);
+  swap(root_type_, other->root_type_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+  swap(_oneof_case_[1], other->_oneof_case_[1]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression_FieldReference::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[45]);
+}
+
+// ===================================================================
+
+class Expression::_Internal {
+ public:
+  static const ::substrait::Expression_Literal& literal(const Expression* msg);
+  static const ::substrait::Expression_FieldReference& selection(const Expression* msg);
+  static const ::substrait::Expression_ScalarFunction& scalar_function(const Expression* msg);
+  static const ::substrait::Expression_WindowFunction& window_function(const Expression* msg);
+  static const ::substrait::Expression_IfThen& if_then(const Expression* msg);
+  static const ::substrait::Expression_SwitchExpression& switch_expression(const Expression* msg);
+  static const ::substrait::Expression_SingularOrList& singular_or_list(const Expression* msg);
+  static const ::substrait::Expression_MultiOrList& multi_or_list(const Expression* msg);
+  static const ::substrait::Expression_Enum& enum_(const Expression* msg);
+  static const ::substrait::Expression_Cast& cast(const Expression* msg);
+};
+
+const ::substrait::Expression_Literal&
+Expression::_Internal::literal(const Expression* msg) {
+  return *msg->rex_type_.literal_;
+}
+const ::substrait::Expression_FieldReference&
+Expression::_Internal::selection(const Expression* msg) {
+  return *msg->rex_type_.selection_;
+}
+const ::substrait::Expression_ScalarFunction&
+Expression::_Internal::scalar_function(const Expression* msg) {
+  return *msg->rex_type_.scalar_function_;
+}
+const ::substrait::Expression_WindowFunction&
+Expression::_Internal::window_function(const Expression* msg) {
+  return *msg->rex_type_.window_function_;
+}
+const ::substrait::Expression_IfThen&
+Expression::_Internal::if_then(const Expression* msg) {
+  return *msg->rex_type_.if_then_;
+}
+const ::substrait::Expression_SwitchExpression&
+Expression::_Internal::switch_expression(const Expression* msg) {
+  return *msg->rex_type_.switch_expression_;
+}
+const ::substrait::Expression_SingularOrList&
+Expression::_Internal::singular_or_list(const Expression* msg) {
+  return *msg->rex_type_.singular_or_list_;
+}
+const ::substrait::Expression_MultiOrList&
+Expression::_Internal::multi_or_list(const Expression* msg) {
+  return *msg->rex_type_.multi_or_list_;
+}
+const ::substrait::Expression_Enum&
+Expression::_Internal::enum_(const Expression* msg) {
+  return *msg->rex_type_.enum__;
+}
+const ::substrait::Expression_Cast&
+Expression::_Internal::cast(const Expression* msg) {
+  return *msg->rex_type_.cast_;
+}
+void Expression::set_allocated_literal(::substrait::Expression_Literal* literal) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rex_type();
+  if (literal) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(literal);
+    if (message_arena != submessage_arena) {
+      literal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, literal, submessage_arena);
+    }
+    set_has_literal();
+    rex_type_.literal_ = literal;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.literal)
+}
+void Expression::set_allocated_selection(::substrait::Expression_FieldReference* selection) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rex_type();
+  if (selection) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_FieldReference>::GetOwningArena(selection);
+    if (message_arena != submessage_arena) {
+      selection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, selection, submessage_arena);
+    }
+    set_has_selection();
+    rex_type_.selection_ = selection;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.selection)
+}
+void Expression::set_allocated_scalar_function(::substrait::Expression_ScalarFunction* scalar_function) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rex_type();
+  if (scalar_function) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ScalarFunction>::GetOwningArena(scalar_function);
+    if (message_arena != submessage_arena) {
+      scalar_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, scalar_function, submessage_arena);
+    }
+    set_has_scalar_function();
+    rex_type_.scalar_function_ = scalar_function;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.scalar_function)
+}
+void Expression::set_allocated_window_function(::substrait::Expression_WindowFunction* window_function) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rex_type();
+  if (window_function) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction>::GetOwningArena(window_function);
+    if (message_arena != submessage_arena) {
+      window_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, window_function, submessage_arena);
+    }
+    set_has_window_function();
+    rex_type_.window_function_ = window_function;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.window_function)
+}
+void Expression::set_allocated_if_then(::substrait::Expression_IfThen* if_then) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rex_type();
+  if (if_then) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_IfThen>::GetOwningArena(if_then);
+    if (message_arena != submessage_arena) {
+      if_then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, if_then, submessage_arena);
+    }
+    set_has_if_then();
+    rex_type_.if_then_ = if_then;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.if_then)
+}
+void Expression::set_allocated_switch_expression(::substrait::Expression_SwitchExpression* switch_expression) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rex_type();
+  if (switch_expression) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_SwitchExpression>::GetOwningArena(switch_expression);
+    if (message_arena != submessage_arena) {
+      switch_expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, switch_expression, submessage_arena);
+    }
+    set_has_switch_expression();
+    rex_type_.switch_expression_ = switch_expression;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.switch_expression)
+}
+void Expression::set_allocated_singular_or_list(::substrait::Expression_SingularOrList* singular_or_list) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rex_type();
+  if (singular_or_list) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_SingularOrList>::GetOwningArena(singular_or_list);
+    if (message_arena != submessage_arena) {
+      singular_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, singular_or_list, submessage_arena);
+    }
+    set_has_singular_or_list();
+    rex_type_.singular_or_list_ = singular_or_list;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.singular_or_list)
+}
+void Expression::set_allocated_multi_or_list(::substrait::Expression_MultiOrList* multi_or_list) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rex_type();
+  if (multi_or_list) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MultiOrList>::GetOwningArena(multi_or_list);
+    if (message_arena != submessage_arena) {
+      multi_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, multi_or_list, submessage_arena);
+    }
+    set_has_multi_or_list();
+    rex_type_.multi_or_list_ = multi_or_list;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.multi_or_list)
+}
+void Expression::set_allocated_enum_(::substrait::Expression_Enum* enum_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rex_type();
+  if (enum_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Enum>::GetOwningArena(enum_);
+    if (message_arena != submessage_arena) {
+      enum_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, enum_, submessage_arena);
+    }
+    set_has_enum_();
+    rex_type_.enum__ = enum_;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.enum)
+}
+void Expression::set_allocated_cast(::substrait::Expression_Cast* cast) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rex_type();
+  if (cast) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Cast>::GetOwningArena(cast);
+    if (message_arena != submessage_arena) {
+      cast = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, cast, submessage_arena);
+    }
+    set_has_cast();
+    rex_type_.cast_ = cast;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.cast)
+}
+Expression::Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Expression)
+}
+Expression::Expression(const Expression& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_rex_type();
+  switch (from.rex_type_case()) {
+    case kLiteral: {
+      _internal_mutable_literal()->::substrait::Expression_Literal::MergeFrom(from._internal_literal());
+      break;
+    }
+    case kSelection: {
+      _internal_mutable_selection()->::substrait::Expression_FieldReference::MergeFrom(from._internal_selection());
+      break;
+    }
+    case kScalarFunction: {
+      _internal_mutable_scalar_function()->::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function());
+      break;
+    }
+    case kWindowFunction: {
+      _internal_mutable_window_function()->::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function());
+      break;
+    }
+    case kIfThen: {
+      _internal_mutable_if_then()->::substrait::Expression_IfThen::MergeFrom(from._internal_if_then());
+      break;
+    }
+    case kSwitchExpression: {
+      _internal_mutable_switch_expression()->::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression());
+      break;
+    }
+    case kSingularOrList: {
+      _internal_mutable_singular_or_list()->::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list());
+      break;
+    }
+    case kMultiOrList: {
+      _internal_mutable_multi_or_list()->::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list());
+      break;
+    }
+    case kEnum: {
+      _internal_mutable_enum_()->::substrait::Expression_Enum::MergeFrom(from._internal_enum_());
+      break;
+    }
+    case kCast: {
+      _internal_mutable_cast()->::substrait::Expression_Cast::MergeFrom(from._internal_cast());
+      break;
+    }
+    case REX_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Expression)
+}
+
+inline void Expression::SharedCtor() {
+clear_has_rex_type();
+}
+
+Expression::~Expression() {
+  // @@protoc_insertion_point(destructor:substrait.Expression)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Expression::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_rex_type()) {
+    clear_rex_type();
+  }
+}
+
+void Expression::ArenaDtor(void* object) {
+  Expression* _this = reinterpret_cast< Expression* >(object);
+  (void)_this;
+}
+void Expression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Expression::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Expression::clear_rex_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Expression)
+  switch (rex_type_case()) {
+    case kLiteral: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rex_type_.literal_;
+      }
+      break;
+    }
+    case kSelection: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rex_type_.selection_;
+      }
+      break;
+    }
+    case kScalarFunction: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rex_type_.scalar_function_;
+      }
+      break;
+    }
+    case kWindowFunction: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rex_type_.window_function_;
+      }
+      break;
+    }
+    case kIfThen: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rex_type_.if_then_;
+      }
+      break;
+    }
+    case kSwitchExpression: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rex_type_.switch_expression_;
+      }
+      break;
+    }
+    case kSingularOrList: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rex_type_.singular_or_list_;
+      }
+      break;
+    }
+    case kMultiOrList: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rex_type_.multi_or_list_;
+      }
+      break;
+    }
+    case kEnum: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rex_type_.enum__;
+      }
+      break;
+    }
+    case kCast: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rex_type_.cast_;
+      }
+      break;
+    }
+    case REX_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = REX_TYPE_NOT_SET;
+}
+
+
+void Expression::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Expression)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_rex_type();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Expression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression.Literal literal = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_literal(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.FieldReference selection = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_selection(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.ScalarFunction scalar_function = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_scalar_function(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.WindowFunction window_function = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_window_function(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.IfThen if_then = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_if_then(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.SwitchExpression switch_expression = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_switch_expression(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.SingularOrList singular_or_list = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_singular_or_list(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.MultiOrList multi_or_list = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_multi_or_list(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.Enum enum = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.Cast cast = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr = ctx->ParseMessage(_internal_mutable_cast(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Expression::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression.Literal literal = 1;
+  if (_internal_has_literal()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::literal(this), target, stream);
+  }
+
+  // .substrait.Expression.FieldReference selection = 2;
+  if (_internal_has_selection()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::selection(this), target, stream);
+  }
+
+  // .substrait.Expression.ScalarFunction scalar_function = 3;
+  if (_internal_has_scalar_function()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::scalar_function(this), target, stream);
+  }
+
+  // .substrait.Expression.WindowFunction window_function = 5;
+  if (_internal_has_window_function()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        5, _Internal::window_function(this), target, stream);
+  }
+
+  // .substrait.Expression.IfThen if_then = 6;
+  if (_internal_has_if_then()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        6, _Internal::if_then(this), target, stream);
+  }
+
+  // .substrait.Expression.SwitchExpression switch_expression = 7;
+  if (_internal_has_switch_expression()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        7, _Internal::switch_expression(this), target, stream);
+  }
+
+  // .substrait.Expression.SingularOrList singular_or_list = 8;
+  if (_internal_has_singular_or_list()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        8, _Internal::singular_or_list(this), target, stream);
+  }
+
+  // .substrait.Expression.MultiOrList multi_or_list = 9;
+  if (_internal_has_multi_or_list()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        9, _Internal::multi_or_list(this), target, stream);
+  }
+
+  // .substrait.Expression.Enum enum = 10;
+  if (_internal_has_enum_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::enum_(this), target, stream);
+  }
+
+  // .substrait.Expression.Cast cast = 11;
+  if (_internal_has_cast()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        11, _Internal::cast(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression)
+  return target;
+}
+
+size_t Expression::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Expression)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (rex_type_case()) {
+    // .substrait.Expression.Literal literal = 1;
+    case kLiteral: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rex_type_.literal_);
+      break;
+    }
+    // .substrait.Expression.FieldReference selection = 2;
+    case kSelection: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rex_type_.selection_);
+      break;
+    }
+    // .substrait.Expression.ScalarFunction scalar_function = 3;
+    case kScalarFunction: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rex_type_.scalar_function_);
+      break;
+    }
+    // .substrait.Expression.WindowFunction window_function = 5;
+    case kWindowFunction: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rex_type_.window_function_);
+      break;
+    }
+    // .substrait.Expression.IfThen if_then = 6;
+    case kIfThen: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rex_type_.if_then_);
+      break;
+    }
+    // .substrait.Expression.SwitchExpression switch_expression = 7;
+    case kSwitchExpression: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rex_type_.switch_expression_);
+      break;
+    }
+    // .substrait.Expression.SingularOrList singular_or_list = 8;
+    case kSingularOrList: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rex_type_.singular_or_list_);
+      break;
+    }
+    // .substrait.Expression.MultiOrList multi_or_list = 9;
+    case kMultiOrList: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rex_type_.multi_or_list_);
+      break;
+    }
+    // .substrait.Expression.Enum enum = 10;
+    case kEnum: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rex_type_.enum__);
+      break;
+    }
+    // .substrait.Expression.Cast cast = 11;
+    case kCast: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rex_type_.cast_);
+      break;
+    }
+    case REX_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Expression::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression::GetClassData() const { return &_class_data_; }
+
+void Expression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Expression *>(to)->MergeFrom(
+      static_cast<const Expression &>(from));
+}
+
+
+void Expression::MergeFrom(const Expression& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.rex_type_case()) {
+    case kLiteral: {
+      _internal_mutable_literal()->::substrait::Expression_Literal::MergeFrom(from._internal_literal());
+      break;
+    }
+    case kSelection: {
+      _internal_mutable_selection()->::substrait::Expression_FieldReference::MergeFrom(from._internal_selection());
+      break;
+    }
+    case kScalarFunction: {
+      _internal_mutable_scalar_function()->::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function());
+      break;
+    }
+    case kWindowFunction: {
+      _internal_mutable_window_function()->::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function());
+      break;
+    }
+    case kIfThen: {
+      _internal_mutable_if_then()->::substrait::Expression_IfThen::MergeFrom(from._internal_if_then());
+      break;
+    }
+    case kSwitchExpression: {
+      _internal_mutable_switch_expression()->::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression());
+      break;
+    }
+    case kSingularOrList: {
+      _internal_mutable_singular_or_list()->::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list());
+      break;
+    }
+    case kMultiOrList: {
+      _internal_mutable_multi_or_list()->::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list());
+      break;
+    }
+    case kEnum: {
+      _internal_mutable_enum_()->::substrait::Expression_Enum::MergeFrom(from._internal_enum_());
+      break;
+    }
+    case kCast: {
+      _internal_mutable_cast()->::substrait::Expression_Cast::MergeFrom(from._internal_cast());
+      break;
+    }
+    case REX_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Expression::CopyFrom(const Expression& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Expression::IsInitialized() const {
+  return true;
+}
+
+void Expression::InternalSwap(Expression* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(rex_type_, other->rex_type_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Expression::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[46]);
+}
+
+// ===================================================================
+
+class SortField::_Internal {
+ public:
+  static const ::substrait::Expression& expr(const SortField* msg);
+};
+
+const ::substrait::Expression&
+SortField::_Internal::expr(const SortField* msg) {
+  return *msg->expr_;
+}
+SortField::SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.SortField)
+}
+SortField::SortField(const SortField& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_expr()) {
+    expr_ = new ::substrait::Expression(*from.expr_);
+  } else {
+    expr_ = nullptr;
+  }
+  clear_has_sort_kind();
+  switch (from.sort_kind_case()) {
+    case kDirection: {
+      _internal_set_direction(from._internal_direction());
+      break;
+    }
+    case kComparisonFunctionReference: {
+      _internal_set_comparison_function_reference(from._internal_comparison_function_reference());
+      break;
+    }
+    case SORT_KIND_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.SortField)
+}
+
+inline void SortField::SharedCtor() {
+expr_ = nullptr;
+clear_has_sort_kind();
+}
+
+SortField::~SortField() {
+  // @@protoc_insertion_point(destructor:substrait.SortField)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void SortField::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete expr_;
+  if (has_sort_kind()) {
+    clear_sort_kind();
+  }
+}
+
+void SortField::ArenaDtor(void* object) {
+  SortField* _this = reinterpret_cast< SortField* >(object);
+  (void)_this;
+}
+void SortField::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void SortField::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void SortField::clear_sort_kind() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.SortField)
+  switch (sort_kind_case()) {
+    case kDirection: {
+      // No need to clear
+      break;
+    }
+    case kComparisonFunctionReference: {
+      // No need to clear
+      break;
+    }
+    case SORT_KIND_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = SORT_KIND_NOT_SET;
+}
+
+
+void SortField::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.SortField)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && expr_ != nullptr) {
+    delete expr_;
+  }
+  expr_ = nullptr;
+  clear_sort_kind();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SortField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Expression expr = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_expr(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.SortField.SortDirection direction = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_direction(static_cast<::substrait::SortField_SortDirection>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 comparison_function_reference = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _internal_set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SortField::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.SortField)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Expression expr = 1;
+  if (this->_internal_has_expr()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::expr(this), target, stream);
+  }
+
+  // .substrait.SortField.SortDirection direction = 2;
+  if (_internal_has_direction()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_direction(), target);
+  }
+
+  // uint32 comparison_function_reference = 3;
+  if (_internal_has_comparison_function_reference()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_comparison_function_reference(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.SortField)
+  return target;
+}
+
+size_t SortField::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.SortField)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Expression expr = 1;
+  if (this->_internal_has_expr()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *expr_);
+  }
+
+  switch (sort_kind_case()) {
+    // .substrait.SortField.SortDirection direction = 2;
+    case kDirection: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_direction());
+      break;
+    }
+    // uint32 comparison_function_reference = 3;
+    case kComparisonFunctionReference: {
+      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_comparison_function_reference());
+      break;
+    }
+    case SORT_KIND_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SortField::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    SortField::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SortField::GetClassData() const { return &_class_data_; }
+
+void SortField::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<SortField *>(to)->MergeFrom(
+      static_cast<const SortField &>(from));
+}
+
+
+void SortField::MergeFrom(const SortField& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.SortField)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_expr()) {
+    _internal_mutable_expr()->::substrait::Expression::MergeFrom(from._internal_expr());
+  }
+  switch (from.sort_kind_case()) {
+    case kDirection: {
+      _internal_set_direction(from._internal_direction());
+      break;
+    }
+    case kComparisonFunctionReference: {
+      _internal_set_comparison_function_reference(from._internal_comparison_function_reference());
+      break;
+    }
+    case SORT_KIND_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SortField::CopyFrom(const SortField& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.SortField)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SortField::IsInitialized() const {
+  return true;
+}
+
+void SortField::InternalSwap(SortField* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(expr_, other->expr_);
+  swap(sort_kind_, other->sort_kind_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SortField::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[47]);
+}
+
+// ===================================================================
+
+class AggregateFunction::_Internal {
+ public:
+  static const ::substrait::Type& output_type(const AggregateFunction* msg);
+};
+
+const ::substrait::Type&
+AggregateFunction::_Internal::output_type(const AggregateFunction* msg) {
+  return *msg->output_type_;
+}
+void AggregateFunction::clear_output_type() {
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+}
+AggregateFunction::AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  args_(arena),
+  sorts_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.AggregateFunction)
+}
+AggregateFunction::AggregateFunction(const AggregateFunction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      args_(from.args_),
+      sorts_(from.sorts_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_output_type()) {
+    output_type_ = new ::substrait::Type(*from.output_type_);
+  } else {
+    output_type_ = nullptr;
+  }
+  ::memcpy(&function_reference_, &from.function_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&phase_) -
+    reinterpret_cast<char*>(&function_reference_)) + sizeof(phase_));
+  // @@protoc_insertion_point(copy_constructor:substrait.AggregateFunction)
+}
+
+inline void AggregateFunction::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&output_type_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&phase_) -
+    reinterpret_cast<char*>(&output_type_)) + sizeof(phase_));
+}
+
+AggregateFunction::~AggregateFunction() {
+  // @@protoc_insertion_point(destructor:substrait.AggregateFunction)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void AggregateFunction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete output_type_;
+}
+
+void AggregateFunction::ArenaDtor(void* object) {
+  AggregateFunction* _this = reinterpret_cast< AggregateFunction* >(object);
+  (void)_this;
+}
+void AggregateFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void AggregateFunction::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void AggregateFunction::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.AggregateFunction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  args_.Clear();
+  sorts_.Clear();
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+  ::memset(&function_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&phase_) -
+      reinterpret_cast<char*>(&function_reference_)) + sizeof(phase_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* AggregateFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 function_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.Expression args = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_args(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.SortField sorts = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_sorts(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.AggregationPhase phase = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_phase(static_cast<::substrait::AggregationPhase>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type output_type = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* AggregateFunction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateFunction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 function_reference = 1;
+  if (this->_internal_function_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target);
+  }
+
+  // repeated .substrait.Expression args = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_args_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_args(i), target, stream);
+  }
+
+  // repeated .substrait.SortField sorts = 3;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_sorts_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, this->_internal_sorts(i), target, stream);
+  }
+
+  // .substrait.AggregationPhase phase = 4;
+  if (this->_internal_phase() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_phase(), target);
+  }
+
+  // .substrait.Type output_type = 5;
+  if (this->_internal_has_output_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        5, _Internal::output_type(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.AggregateFunction)
+  return target;
+}
+
+size_t AggregateFunction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateFunction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression args = 2;
+  total_size += 1UL * this->_internal_args_size();
+  for (const auto& msg : this->args_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .substrait.SortField sorts = 3;
+  total_size += 1UL * this->_internal_sorts_size();
+  for (const auto& msg : this->sorts_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.Type output_type = 5;
+  if (this->_internal_has_output_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *output_type_);
+  }
+
+  // uint32 function_reference = 1;
+  if (this->_internal_function_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_reference());
+  }
+
+  // .substrait.AggregationPhase phase = 4;
+  if (this->_internal_phase() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateFunction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    AggregateFunction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateFunction::GetClassData() const { return &_class_data_; }
+
+void AggregateFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<AggregateFunction *>(to)->MergeFrom(
+      static_cast<const AggregateFunction &>(from));
+}
+
+
+void AggregateFunction::MergeFrom(const AggregateFunction& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateFunction)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  args_.MergeFrom(from.args_);
+  sorts_.MergeFrom(from.sorts_);
+  if (from._internal_has_output_type()) {
+    _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type());
+  }
+  if (from._internal_function_reference() != 0) {
+    _internal_set_function_reference(from._internal_function_reference());
+  }
+  if (from._internal_phase() != 0) {
+    _internal_set_phase(from._internal_phase());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void AggregateFunction::CopyFrom(const AggregateFunction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateFunction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AggregateFunction::IsInitialized() const {
+  return true;
+}
+
+void AggregateFunction::InternalSwap(AggregateFunction* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  args_.InternalSwap(&other->args_);
+  sorts_.InternalSwap(&other->sorts_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(AggregateFunction, phase_)
+      + sizeof(AggregateFunction::phase_)
+      - PROTOBUF_FIELD_OFFSET(AggregateFunction, output_type_)>(
+          reinterpret_cast<char*>(&output_type_),
+          reinterpret_cast<char*>(&other->output_type_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata AggregateFunction::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once,
+      file_level_metadata_substrait_2fexpression_2eproto[48]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::substrait::Expression_Enum_Empty* Arena::CreateMaybeMessage< ::substrait::Expression_Enum_Empty >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_Enum_Empty >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_Enum* Arena::CreateMaybeMessage< ::substrait::Expression_Enum >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_Enum >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_VarChar* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_VarChar >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_VarChar >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Decimal* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Decimal >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Decimal >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Map_KeyValue >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Map_KeyValue >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Map* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Map >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Map >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_IntervalYearToMonth* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_IntervalYearToMonth >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_IntervalYearToMonth >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_IntervalDayToSecond* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_IntervalDayToSecond >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_IntervalDayToSecond >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Struct* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Struct >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Struct >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_List* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_List >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_Literal_List >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal* Arena::CreateMaybeMessage< ::substrait::Expression_Literal >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_Literal >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage< ::substrait::Expression_ScalarFunction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_ScalarFunction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Preceding >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_Preceding >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_Following* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Following >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_Following >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_CurrentRow* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_Unbounded* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Unbounded >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_Unbounded >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage< ::substrait::Expression_IfThen_IfClause >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_IfThen_IfClause >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_IfThen* Arena::CreateMaybeMessage< ::substrait::Expression_IfThen >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_IfThen >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_Cast* Arena::CreateMaybeMessage< ::substrait::Expression_Cast >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_Cast >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage< ::substrait::Expression_SwitchExpression_IfValue >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_SwitchExpression_IfValue >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_SwitchExpression* Arena::CreateMaybeMessage< ::substrait::Expression_SwitchExpression >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_SwitchExpression >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_SingularOrList* Arena::CreateMaybeMessage< ::substrait::Expression_SingularOrList >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_SingularOrList >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MultiOrList_Record* Arena::CreateMaybeMessage< ::substrait::Expression_MultiOrList_Record >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MultiOrList_Record >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MultiOrList* Arena::CreateMaybeMessage< ::substrait::Expression_MultiOrList >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MultiOrList >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Arena::CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Arena::CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_EmbeddedFunction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment_MapKey* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_MapKey >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment_MapKey >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment_StructField* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_StructField >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment_StructField >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment_ListElement* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_ListElement >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment_ListElement >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_Select* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_Select >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_Select >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_StructSelect* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructSelect >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_StructSelect >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_StructItem* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructItem >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_StructItem >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_MapSelect* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_MapSelect >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_FieldReference_RootReference* Arena::CreateMaybeMessage< ::substrait::Expression_FieldReference_RootReference >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_FieldReference_RootReference >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression_FieldReference* Arena::CreateMaybeMessage< ::substrait::Expression_FieldReference >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression_FieldReference >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Expression* Arena::CreateMaybeMessage< ::substrait::Expression >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Expression >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::SortField* Arena::CreateMaybeMessage< ::substrait::SortField >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::SortField >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::AggregateFunction* Arena::CreateMaybeMessage< ::substrait::AggregateFunction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::AggregateFunction >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/cpp/src/generated/substrait/expression.pb.h b/cpp/src/generated/substrait/expression.pb.h
new file mode 100644
index 000000000000..b7c2a920316c
--- /dev/null
+++ b/cpp/src/generated/substrait/expression.pb.h
@@ -0,0 +1,18033 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/expression.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fexpression_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fexpression_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3019000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3019003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_bases.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "substrait/type.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_substrait_2fexpression_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_substrait_2fexpression_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[49]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fexpression_2eproto;
+namespace substrait {
+class AggregateFunction;
+struct AggregateFunctionDefaultTypeInternal;
+extern AggregateFunctionDefaultTypeInternal _AggregateFunction_default_instance_;
+class Expression;
+struct ExpressionDefaultTypeInternal;
+extern ExpressionDefaultTypeInternal _Expression_default_instance_;
+class Expression_Cast;
+struct Expression_CastDefaultTypeInternal;
+extern Expression_CastDefaultTypeInternal _Expression_Cast_default_instance_;
+class Expression_EmbeddedFunction;
+struct Expression_EmbeddedFunctionDefaultTypeInternal;
+extern Expression_EmbeddedFunctionDefaultTypeInternal _Expression_EmbeddedFunction_default_instance_;
+class Expression_EmbeddedFunction_PythonPickleFunction;
+struct Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal;
+extern Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal _Expression_EmbeddedFunction_PythonPickleFunction_default_instance_;
+class Expression_EmbeddedFunction_WebAssemblyFunction;
+struct Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal;
+extern Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal _Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_;
+class Expression_Enum;
+struct Expression_EnumDefaultTypeInternal;
+extern Expression_EnumDefaultTypeInternal _Expression_Enum_default_instance_;
+class Expression_Enum_Empty;
+struct Expression_Enum_EmptyDefaultTypeInternal;
+extern Expression_Enum_EmptyDefaultTypeInternal _Expression_Enum_Empty_default_instance_;
+class Expression_FieldReference;
+struct Expression_FieldReferenceDefaultTypeInternal;
+extern Expression_FieldReferenceDefaultTypeInternal _Expression_FieldReference_default_instance_;
+class Expression_FieldReference_RootReference;
+struct Expression_FieldReference_RootReferenceDefaultTypeInternal;
+extern Expression_FieldReference_RootReferenceDefaultTypeInternal _Expression_FieldReference_RootReference_default_instance_;
+class Expression_IfThen;
+struct Expression_IfThenDefaultTypeInternal;
+extern Expression_IfThenDefaultTypeInternal _Expression_IfThen_default_instance_;
+class Expression_IfThen_IfClause;
+struct Expression_IfThen_IfClauseDefaultTypeInternal;
+extern Expression_IfThen_IfClauseDefaultTypeInternal _Expression_IfThen_IfClause_default_instance_;
+class Expression_Literal;
+struct Expression_LiteralDefaultTypeInternal;
+extern Expression_LiteralDefaultTypeInternal _Expression_Literal_default_instance_;
+class Expression_Literal_Decimal;
+struct Expression_Literal_DecimalDefaultTypeInternal;
+extern Expression_Literal_DecimalDefaultTypeInternal _Expression_Literal_Decimal_default_instance_;
+class Expression_Literal_IntervalDayToSecond;
+struct Expression_Literal_IntervalDayToSecondDefaultTypeInternal;
+extern Expression_Literal_IntervalDayToSecondDefaultTypeInternal _Expression_Literal_IntervalDayToSecond_default_instance_;
+class Expression_Literal_IntervalYearToMonth;
+struct Expression_Literal_IntervalYearToMonthDefaultTypeInternal;
+extern Expression_Literal_IntervalYearToMonthDefaultTypeInternal _Expression_Literal_IntervalYearToMonth_default_instance_;
+class Expression_Literal_List;
+struct Expression_Literal_ListDefaultTypeInternal;
+extern Expression_Literal_ListDefaultTypeInternal _Expression_Literal_List_default_instance_;
+class Expression_Literal_Map;
+struct Expression_Literal_MapDefaultTypeInternal;
+extern Expression_Literal_MapDefaultTypeInternal _Expression_Literal_Map_default_instance_;
+class Expression_Literal_Map_KeyValue;
+struct Expression_Literal_Map_KeyValueDefaultTypeInternal;
+extern Expression_Literal_Map_KeyValueDefaultTypeInternal _Expression_Literal_Map_KeyValue_default_instance_;
+class Expression_Literal_Struct;
+struct Expression_Literal_StructDefaultTypeInternal;
+extern Expression_Literal_StructDefaultTypeInternal _Expression_Literal_Struct_default_instance_;
+class Expression_Literal_VarChar;
+struct Expression_Literal_VarCharDefaultTypeInternal;
+extern Expression_Literal_VarCharDefaultTypeInternal _Expression_Literal_VarChar_default_instance_;
+class Expression_MaskExpression;
+struct Expression_MaskExpressionDefaultTypeInternal;
+extern Expression_MaskExpressionDefaultTypeInternal _Expression_MaskExpression_default_instance_;
+class Expression_MaskExpression_ListSelect;
+struct Expression_MaskExpression_ListSelectDefaultTypeInternal;
+extern Expression_MaskExpression_ListSelectDefaultTypeInternal _Expression_MaskExpression_ListSelect_default_instance_;
+class Expression_MaskExpression_ListSelect_ListSelectItem;
+struct Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal;
+extern Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_;
+class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement;
+struct Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal;
+extern Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_;
+class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice;
+struct Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal;
+extern Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_;
+class Expression_MaskExpression_MapSelect;
+struct Expression_MaskExpression_MapSelectDefaultTypeInternal;
+extern Expression_MaskExpression_MapSelectDefaultTypeInternal _Expression_MaskExpression_MapSelect_default_instance_;
+class Expression_MaskExpression_MapSelect_MapKey;
+struct Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal;
+extern Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKey_default_instance_;
+class Expression_MaskExpression_MapSelect_MapKeyExpression;
+struct Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal;
+extern Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_;
+class Expression_MaskExpression_Select;
+struct Expression_MaskExpression_SelectDefaultTypeInternal;
+extern Expression_MaskExpression_SelectDefaultTypeInternal _Expression_MaskExpression_Select_default_instance_;
+class Expression_MaskExpression_StructItem;
+struct Expression_MaskExpression_StructItemDefaultTypeInternal;
+extern Expression_MaskExpression_StructItemDefaultTypeInternal _Expression_MaskExpression_StructItem_default_instance_;
+class Expression_MaskExpression_StructSelect;
+struct Expression_MaskExpression_StructSelectDefaultTypeInternal;
+extern Expression_MaskExpression_StructSelectDefaultTypeInternal _Expression_MaskExpression_StructSelect_default_instance_;
+class Expression_MultiOrList;
+struct Expression_MultiOrListDefaultTypeInternal;
+extern Expression_MultiOrListDefaultTypeInternal _Expression_MultiOrList_default_instance_;
+class Expression_MultiOrList_Record;
+struct Expression_MultiOrList_RecordDefaultTypeInternal;
+extern Expression_MultiOrList_RecordDefaultTypeInternal _Expression_MultiOrList_Record_default_instance_;
+class Expression_ReferenceSegment;
+struct Expression_ReferenceSegmentDefaultTypeInternal;
+extern Expression_ReferenceSegmentDefaultTypeInternal _Expression_ReferenceSegment_default_instance_;
+class Expression_ReferenceSegment_ListElement;
+struct Expression_ReferenceSegment_ListElementDefaultTypeInternal;
+extern Expression_ReferenceSegment_ListElementDefaultTypeInternal _Expression_ReferenceSegment_ListElement_default_instance_;
+class Expression_ReferenceSegment_MapKey;
+struct Expression_ReferenceSegment_MapKeyDefaultTypeInternal;
+extern Expression_ReferenceSegment_MapKeyDefaultTypeInternal _Expression_ReferenceSegment_MapKey_default_instance_;
+class Expression_ReferenceSegment_StructField;
+struct Expression_ReferenceSegment_StructFieldDefaultTypeInternal;
+extern Expression_ReferenceSegment_StructFieldDefaultTypeInternal _Expression_ReferenceSegment_StructField_default_instance_;
+class Expression_ScalarFunction;
+struct Expression_ScalarFunctionDefaultTypeInternal;
+extern Expression_ScalarFunctionDefaultTypeInternal _Expression_ScalarFunction_default_instance_;
+class Expression_SingularOrList;
+struct Expression_SingularOrListDefaultTypeInternal;
+extern Expression_SingularOrListDefaultTypeInternal _Expression_SingularOrList_default_instance_;
+class Expression_SwitchExpression;
+struct Expression_SwitchExpressionDefaultTypeInternal;
+extern Expression_SwitchExpressionDefaultTypeInternal _Expression_SwitchExpression_default_instance_;
+class Expression_SwitchExpression_IfValue;
+struct Expression_SwitchExpression_IfValueDefaultTypeInternal;
+extern Expression_SwitchExpression_IfValueDefaultTypeInternal _Expression_SwitchExpression_IfValue_default_instance_;
+class Expression_WindowFunction;
+struct Expression_WindowFunctionDefaultTypeInternal;
+extern Expression_WindowFunctionDefaultTypeInternal _Expression_WindowFunction_default_instance_;
+class Expression_WindowFunction_Bound;
+struct Expression_WindowFunction_BoundDefaultTypeInternal;
+extern Expression_WindowFunction_BoundDefaultTypeInternal _Expression_WindowFunction_Bound_default_instance_;
+class Expression_WindowFunction_Bound_CurrentRow;
+struct Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal;
+extern Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal _Expression_WindowFunction_Bound_CurrentRow_default_instance_;
+class Expression_WindowFunction_Bound_Following;
+struct Expression_WindowFunction_Bound_FollowingDefaultTypeInternal;
+extern Expression_WindowFunction_Bound_FollowingDefaultTypeInternal _Expression_WindowFunction_Bound_Following_default_instance_;
+class Expression_WindowFunction_Bound_Preceding;
+struct Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal;
+extern Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal _Expression_WindowFunction_Bound_Preceding_default_instance_;
+class Expression_WindowFunction_Bound_Unbounded;
+struct Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal;
+extern Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal _Expression_WindowFunction_Bound_Unbounded_default_instance_;
+class SortField;
+struct SortFieldDefaultTypeInternal;
+extern SortFieldDefaultTypeInternal _SortField_default_instance_;
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> ::substrait::AggregateFunction* Arena::CreateMaybeMessage<::substrait::AggregateFunction>(Arena*);
+template<> ::substrait::Expression* Arena::CreateMaybeMessage<::substrait::Expression>(Arena*);
+template<> ::substrait::Expression_Cast* Arena::CreateMaybeMessage<::substrait::Expression_Cast>(Arena*);
+template<> ::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage<::substrait::Expression_EmbeddedFunction>(Arena*);
+template<> ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Arena::CreateMaybeMessage<::substrait::Expression_EmbeddedFunction_PythonPickleFunction>(Arena*);
+template<> ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Arena::CreateMaybeMessage<::substrait::Expression_EmbeddedFunction_WebAssemblyFunction>(Arena*);
+template<> ::substrait::Expression_Enum* Arena::CreateMaybeMessage<::substrait::Expression_Enum>(Arena*);
+template<> ::substrait::Expression_Enum_Empty* Arena::CreateMaybeMessage<::substrait::Expression_Enum_Empty>(Arena*);
+template<> ::substrait::Expression_FieldReference* Arena::CreateMaybeMessage<::substrait::Expression_FieldReference>(Arena*);
+template<> ::substrait::Expression_FieldReference_RootReference* Arena::CreateMaybeMessage<::substrait::Expression_FieldReference_RootReference>(Arena*);
+template<> ::substrait::Expression_IfThen* Arena::CreateMaybeMessage<::substrait::Expression_IfThen>(Arena*);
+template<> ::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage<::substrait::Expression_IfThen_IfClause>(Arena*);
+template<> ::substrait::Expression_Literal* Arena::CreateMaybeMessage<::substrait::Expression_Literal>(Arena*);
+template<> ::substrait::Expression_Literal_Decimal* Arena::CreateMaybeMessage<::substrait::Expression_Literal_Decimal>(Arena*);
+template<> ::substrait::Expression_Literal_IntervalDayToSecond* Arena::CreateMaybeMessage<::substrait::Expression_Literal_IntervalDayToSecond>(Arena*);
+template<> ::substrait::Expression_Literal_IntervalYearToMonth* Arena::CreateMaybeMessage<::substrait::Expression_Literal_IntervalYearToMonth>(Arena*);
+template<> ::substrait::Expression_Literal_List* Arena::CreateMaybeMessage<::substrait::Expression_Literal_List>(Arena*);
+template<> ::substrait::Expression_Literal_Map* Arena::CreateMaybeMessage<::substrait::Expression_Literal_Map>(Arena*);
+template<> ::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage<::substrait::Expression_Literal_Map_KeyValue>(Arena*);
+template<> ::substrait::Expression_Literal_Struct* Arena::CreateMaybeMessage<::substrait::Expression_Literal_Struct>(Arena*);
+template<> ::substrait::Expression_Literal_VarChar* Arena::CreateMaybeMessage<::substrait::Expression_Literal_VarChar>(Arena*);
+template<> ::substrait::Expression_MaskExpression* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression>(Arena*);
+template<> ::substrait::Expression_MaskExpression_ListSelect* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_ListSelect>(Arena*);
+template<> ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem>(Arena*);
+template<> ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement>(Arena*);
+template<> ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice>(Arena*);
+template<> ::substrait::Expression_MaskExpression_MapSelect* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_MapSelect>(Arena*);
+template<> ::substrait::Expression_MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_MapSelect_MapKey>(Arena*);
+template<> ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression>(Arena*);
+template<> ::substrait::Expression_MaskExpression_Select* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(Arena*);
+template<> ::substrait::Expression_MaskExpression_StructItem* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_StructItem>(Arena*);
+template<> ::substrait::Expression_MaskExpression_StructSelect* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_StructSelect>(Arena*);
+template<> ::substrait::Expression_MultiOrList* Arena::CreateMaybeMessage<::substrait::Expression_MultiOrList>(Arena*);
+template<> ::substrait::Expression_MultiOrList_Record* Arena::CreateMaybeMessage<::substrait::Expression_MultiOrList_Record>(Arena*);
+template<> ::substrait::Expression_ReferenceSegment* Arena::CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(Arena*);
+template<> ::substrait::Expression_ReferenceSegment_ListElement* Arena::CreateMaybeMessage<::substrait::Expression_ReferenceSegment_ListElement>(Arena*);
+template<> ::substrait::Expression_ReferenceSegment_MapKey* Arena::CreateMaybeMessage<::substrait::Expression_ReferenceSegment_MapKey>(Arena*);
+template<> ::substrait::Expression_ReferenceSegment_StructField* Arena::CreateMaybeMessage<::substrait::Expression_ReferenceSegment_StructField>(Arena*);
+template<> ::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage<::substrait::Expression_ScalarFunction>(Arena*);
+template<> ::substrait::Expression_SingularOrList* Arena::CreateMaybeMessage<::substrait::Expression_SingularOrList>(Arena*);
+template<> ::substrait::Expression_SwitchExpression* Arena::CreateMaybeMessage<::substrait::Expression_SwitchExpression>(Arena*);
+template<> ::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage<::substrait::Expression_SwitchExpression_IfValue>(Arena*);
+template<> ::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction>(Arena*);
+template<> ::substrait::Expression_WindowFunction_Bound* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(Arena*);
+template<> ::substrait::Expression_WindowFunction_Bound_CurrentRow* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound_CurrentRow>(Arena*);
+template<> ::substrait::Expression_WindowFunction_Bound_Following* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound_Following>(Arena*);
+template<> ::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound_Preceding>(Arena*);
+template<> ::substrait::Expression_WindowFunction_Bound_Unbounded* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound_Unbounded>(Arena*);
+template<> ::substrait::SortField* Arena::CreateMaybeMessage<::substrait::SortField>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace substrait {
+
+enum SortField_SortDirection : int {
+  SortField_SortDirection_SORT_DIRECTION_UNSPECIFIED = 0,
+  SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_FIRST = 1,
+  SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_LAST = 2,
+  SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_FIRST = 3,
+  SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_LAST = 4,
+  SortField_SortDirection_SORT_DIRECTION_CLUSTERED = 5,
+  SortField_SortDirection_SortField_SortDirection_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  SortField_SortDirection_SortField_SortDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool SortField_SortDirection_IsValid(int value);
+constexpr SortField_SortDirection SortField_SortDirection_SortDirection_MIN = SortField_SortDirection_SORT_DIRECTION_UNSPECIFIED;
+constexpr SortField_SortDirection SortField_SortDirection_SortDirection_MAX = SortField_SortDirection_SORT_DIRECTION_CLUSTERED;
+constexpr int SortField_SortDirection_SortDirection_ARRAYSIZE = SortField_SortDirection_SortDirection_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortField_SortDirection_descriptor();
+template<typename T>
+inline const std::string& SortField_SortDirection_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SortField_SortDirection>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SortField_SortDirection_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SortField_SortDirection_descriptor(), enum_t_value);
+}
+inline bool SortField_SortDirection_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SortField_SortDirection* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SortField_SortDirection>(
+    SortField_SortDirection_descriptor(), name, value);
+}
+enum AggregationPhase : int {
+  AGGREGATION_PHASE_UNSPECIFIED = 0,
+  AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE = 1,
+  AGGREGATION_PHASE_INTERMEDIATE_TO_INTERMEDIATE = 2,
+  AGGREGATION_PHASE_INITIAL_TO_RESULT = 3,
+  AGGREGATION_PHASE_INTERMEDIATE_TO_RESULT = 4,
+  AggregationPhase_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  AggregationPhase_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool AggregationPhase_IsValid(int value);
+constexpr AggregationPhase AggregationPhase_MIN = AGGREGATION_PHASE_UNSPECIFIED;
+constexpr AggregationPhase AggregationPhase_MAX = AGGREGATION_PHASE_INTERMEDIATE_TO_RESULT;
+constexpr int AggregationPhase_ARRAYSIZE = AggregationPhase_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggregationPhase_descriptor();
+template<typename T>
+inline const std::string& AggregationPhase_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, AggregationPhase>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function AggregationPhase_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    AggregationPhase_descriptor(), enum_t_value);
+}
+inline bool AggregationPhase_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AggregationPhase* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AggregationPhase>(
+    AggregationPhase_descriptor(), name, value);
+}
+// ===================================================================
+
+class Expression_Enum_Empty final :
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.Expression.Enum.Empty) */ {
+ public:
+  inline Expression_Enum_Empty() : Expression_Enum_Empty(nullptr) {}
+  explicit constexpr Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_Enum_Empty(const Expression_Enum_Empty& from);
+  Expression_Enum_Empty(Expression_Enum_Empty&& from) noexcept
+    : Expression_Enum_Empty() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_Enum_Empty& operator=(const Expression_Enum_Empty& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_Enum_Empty& operator=(Expression_Enum_Empty&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_Enum_Empty& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_Enum_Empty* internal_default_instance() {
+    return reinterpret_cast<const Expression_Enum_Empty*>(
+               &_Expression_Enum_Empty_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Expression_Enum_Empty& a, Expression_Enum_Empty& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_Enum_Empty* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_Enum_Empty* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_Enum_Empty* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_Enum_Empty>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
+  inline void CopyFrom(const Expression_Enum_Empty& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
+  void MergeFrom(const Expression_Enum_Empty& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
+  }
+  public:
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.Enum.Empty";
+  }
+  protected:
+  explicit Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.Enum.Empty)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_Enum final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Enum) */ {
+ public:
+  inline Expression_Enum() : Expression_Enum(nullptr) {}
+  ~Expression_Enum() override;
+  explicit constexpr Expression_Enum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_Enum(const Expression_Enum& from);
+  Expression_Enum(Expression_Enum&& from) noexcept
+    : Expression_Enum() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_Enum& operator=(const Expression_Enum& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_Enum& operator=(Expression_Enum&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_Enum& default_instance() {
+    return *internal_default_instance();
+  }
+  enum EnumKindCase {
+    kSpecified = 1,
+    kUnspecified = 2,
+    ENUM_KIND_NOT_SET = 0,
+  };
+
+  static inline const Expression_Enum* internal_default_instance() {
+    return reinterpret_cast<const Expression_Enum*>(
+               &_Expression_Enum_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(Expression_Enum& a, Expression_Enum& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_Enum* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_Enum* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_Enum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_Enum>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_Enum& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_Enum& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_Enum* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.Enum";
+  }
+  protected:
+  explicit Expression_Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_Enum_Empty Empty;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSpecifiedFieldNumber = 1,
+    kUnspecifiedFieldNumber = 2,
+  };
+  // string specified = 1;
+  bool has_specified() const;
+  private:
+  bool _internal_has_specified() const;
+  public:
+  void clear_specified();
+  const std::string& specified() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_specified(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_specified();
+  PROTOBUF_NODISCARD std::string* release_specified();
+  void set_allocated_specified(std::string* specified);
+  private:
+  const std::string& _internal_specified() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_specified(const std::string& value);
+  std::string* _internal_mutable_specified();
+  public:
+
+  // .substrait.Expression.Enum.Empty unspecified = 2;
+  bool has_unspecified() const;
+  private:
+  bool _internal_has_unspecified() const;
+  public:
+  void clear_unspecified();
+  const ::substrait::Expression_Enum_Empty& unspecified() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Enum_Empty* release_unspecified();
+  ::substrait::Expression_Enum_Empty* mutable_unspecified();
+  void set_allocated_unspecified(::substrait::Expression_Enum_Empty* unspecified);
+  private:
+  const ::substrait::Expression_Enum_Empty& _internal_unspecified() const;
+  ::substrait::Expression_Enum_Empty* _internal_mutable_unspecified();
+  public:
+  void unsafe_arena_set_allocated_unspecified(
+      ::substrait::Expression_Enum_Empty* unspecified);
+  ::substrait::Expression_Enum_Empty* unsafe_arena_release_unspecified();
+
+  void clear_enum_kind();
+  EnumKindCase enum_kind_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.Expression.Enum)
+ private:
+  class _Internal;
+  void set_has_specified();
+  void set_has_unspecified();
+
+  inline bool has_enum_kind() const;
+  inline void clear_has_enum_kind();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union EnumKindUnion {
+    constexpr EnumKindUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr specified_;
+    ::substrait::Expression_Enum_Empty* unspecified_;
+  } enum_kind_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_Literal_VarChar final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.VarChar) */ {
+ public:
+  inline Expression_Literal_VarChar() : Expression_Literal_VarChar(nullptr) {}
+  ~Expression_Literal_VarChar() override;
+  explicit constexpr Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_Literal_VarChar(const Expression_Literal_VarChar& from);
+  Expression_Literal_VarChar(Expression_Literal_VarChar&& from) noexcept
+    : Expression_Literal_VarChar() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_Literal_VarChar& operator=(const Expression_Literal_VarChar& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_Literal_VarChar& operator=(Expression_Literal_VarChar&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_Literal_VarChar& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_Literal_VarChar* internal_default_instance() {
+    return reinterpret_cast<const Expression_Literal_VarChar*>(
+               &_Expression_Literal_VarChar_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(Expression_Literal_VarChar& a, Expression_Literal_VarChar& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_Literal_VarChar* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_Literal_VarChar* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_Literal_VarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_Literal_VarChar>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_Literal_VarChar& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_Literal_VarChar& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_Literal_VarChar* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.Literal.VarChar";
+  }
+  protected:
+  explicit Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+    kLengthFieldNumber = 2,
+  };
+  // string value = 1;
+  void clear_value();
+  const std::string& value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_value();
+  PROTOBUF_NODISCARD std::string* release_value();
+  void set_allocated_value(std::string* value);
+  private:
+  const std::string& _internal_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+  std::string* _internal_mutable_value();
+  public:
+
+  // uint32 length = 2;
+  void clear_length();
+  uint32_t length() const;
+  void set_length(uint32_t value);
+  private:
+  uint32_t _internal_length() const;
+  void _internal_set_length(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.VarChar)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+  uint32_t length_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_Literal_Decimal final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Decimal) */ {
+ public:
+  inline Expression_Literal_Decimal() : Expression_Literal_Decimal(nullptr) {}
+  ~Expression_Literal_Decimal() override;
+  explicit constexpr Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_Literal_Decimal(const Expression_Literal_Decimal& from);
+  Expression_Literal_Decimal(Expression_Literal_Decimal&& from) noexcept
+    : Expression_Literal_Decimal() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_Literal_Decimal& operator=(const Expression_Literal_Decimal& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_Literal_Decimal& operator=(Expression_Literal_Decimal&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_Literal_Decimal& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_Literal_Decimal* internal_default_instance() {
+    return reinterpret_cast<const Expression_Literal_Decimal*>(
+               &_Expression_Literal_Decimal_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(Expression_Literal_Decimal& a, Expression_Literal_Decimal& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_Literal_Decimal* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_Literal_Decimal* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_Literal_Decimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_Literal_Decimal>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_Literal_Decimal& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_Literal_Decimal& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_Literal_Decimal* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.Literal.Decimal";
+  }
+  protected:
+  explicit Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+    kPrecisionFieldNumber = 2,
+    kScaleFieldNumber = 3,
+  };
+  // bytes value = 1;
+  void clear_value();
+  const std::string& value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_value();
+  PROTOBUF_NODISCARD std::string* release_value();
+  void set_allocated_value(std::string* value);
+  private:
+  const std::string& _internal_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+  std::string* _internal_mutable_value();
+  public:
+
+  // int32 precision = 2;
+  void clear_precision();
+  int32_t precision() const;
+  void set_precision(int32_t value);
+  private:
+  int32_t _internal_precision() const;
+  void _internal_set_precision(int32_t value);
+  public:
+
+  // int32 scale = 3;
+  void clear_scale();
+  int32_t scale() const;
+  void set_scale(int32_t value);
+  private:
+  int32_t _internal_scale() const;
+  void _internal_set_scale(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Decimal)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+  int32_t precision_;
+  int32_t scale_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_Literal_Map_KeyValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Map.KeyValue) */ {
+ public:
+  inline Expression_Literal_Map_KeyValue() : Expression_Literal_Map_KeyValue(nullptr) {}
+  ~Expression_Literal_Map_KeyValue() override;
+  explicit constexpr Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_Literal_Map_KeyValue(const Expression_Literal_Map_KeyValue& from);
+  Expression_Literal_Map_KeyValue(Expression_Literal_Map_KeyValue&& from) noexcept
+    : Expression_Literal_Map_KeyValue() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_Literal_Map_KeyValue& operator=(const Expression_Literal_Map_KeyValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_Literal_Map_KeyValue& operator=(Expression_Literal_Map_KeyValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_Literal_Map_KeyValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_Literal_Map_KeyValue* internal_default_instance() {
+    return reinterpret_cast<const Expression_Literal_Map_KeyValue*>(
+               &_Expression_Literal_Map_KeyValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(Expression_Literal_Map_KeyValue& a, Expression_Literal_Map_KeyValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_Literal_Map_KeyValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_Literal_Map_KeyValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_Literal_Map_KeyValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_Literal_Map_KeyValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_Literal_Map_KeyValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_Literal_Map_KeyValue& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_Literal_Map_KeyValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.Literal.Map.KeyValue";
+  }
+  protected:
+  explicit Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  // .substrait.Expression.Literal key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::substrait::Expression_Literal& key() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_key();
+  ::substrait::Expression_Literal* mutable_key();
+  void set_allocated_key(::substrait::Expression_Literal* key);
+  private:
+  const ::substrait::Expression_Literal& _internal_key() const;
+  ::substrait::Expression_Literal* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::substrait::Expression_Literal* key);
+  ::substrait::Expression_Literal* unsafe_arena_release_key();
+
+  // .substrait.Expression.Literal value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const ::substrait::Expression_Literal& value() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_value();
+  ::substrait::Expression_Literal* mutable_value();
+  void set_allocated_value(::substrait::Expression_Literal* value);
+  private:
+  const ::substrait::Expression_Literal& _internal_value() const;
+  ::substrait::Expression_Literal* _internal_mutable_value();
+  public:
+  void unsafe_arena_set_allocated_value(
+      ::substrait::Expression_Literal* value);
+  ::substrait::Expression_Literal* unsafe_arena_release_value();
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Map.KeyValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Expression_Literal* key_;
+  ::substrait::Expression_Literal* value_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_Literal_Map final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Map) */ {
+ public:
+  inline Expression_Literal_Map() : Expression_Literal_Map(nullptr) {}
+  ~Expression_Literal_Map() override;
+  explicit constexpr Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_Literal_Map(const Expression_Literal_Map& from);
+  Expression_Literal_Map(Expression_Literal_Map&& from) noexcept
+    : Expression_Literal_Map() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_Literal_Map& operator=(const Expression_Literal_Map& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_Literal_Map& operator=(Expression_Literal_Map&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_Literal_Map& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_Literal_Map* internal_default_instance() {
+    return reinterpret_cast<const Expression_Literal_Map*>(
+               &_Expression_Literal_Map_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(Expression_Literal_Map& a, Expression_Literal_Map& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_Literal_Map* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_Literal_Map* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_Literal_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_Literal_Map>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_Literal_Map& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_Literal_Map& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_Literal_Map* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.Literal.Map";
+  }
+  protected:
+  explicit Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_Literal_Map_KeyValue KeyValue;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyValuesFieldNumber = 1,
+  };
+  // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1;
+  int key_values_size() const;
+  private:
+  int _internal_key_values_size() const;
+  public:
+  void clear_key_values();
+  ::substrait::Expression_Literal_Map_KeyValue* mutable_key_values(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >*
+      mutable_key_values();
+  private:
+  const ::substrait::Expression_Literal_Map_KeyValue& _internal_key_values(int index) const;
+  ::substrait::Expression_Literal_Map_KeyValue* _internal_add_key_values();
+  public:
+  const ::substrait::Expression_Literal_Map_KeyValue& key_values(int index) const;
+  ::substrait::Expression_Literal_Map_KeyValue* add_key_values();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >&
+      key_values() const;
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Map)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue > key_values_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_Literal_IntervalYearToMonth final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.IntervalYearToMonth) */ {
+ public:
+  inline Expression_Literal_IntervalYearToMonth() : Expression_Literal_IntervalYearToMonth(nullptr) {}
+  ~Expression_Literal_IntervalYearToMonth() override;
+  explicit constexpr Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_Literal_IntervalYearToMonth(const Expression_Literal_IntervalYearToMonth& from);
+  Expression_Literal_IntervalYearToMonth(Expression_Literal_IntervalYearToMonth&& from) noexcept
+    : Expression_Literal_IntervalYearToMonth() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_Literal_IntervalYearToMonth& operator=(const Expression_Literal_IntervalYearToMonth& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_Literal_IntervalYearToMonth& operator=(Expression_Literal_IntervalYearToMonth&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_Literal_IntervalYearToMonth& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_Literal_IntervalYearToMonth* internal_default_instance() {
+    return reinterpret_cast<const Expression_Literal_IntervalYearToMonth*>(
+               &_Expression_Literal_IntervalYearToMonth_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(Expression_Literal_IntervalYearToMonth& a, Expression_Literal_IntervalYearToMonth& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_Literal_IntervalYearToMonth* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_Literal_IntervalYearToMonth* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_Literal_IntervalYearToMonth* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_Literal_IntervalYearToMonth>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_Literal_IntervalYearToMonth& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_Literal_IntervalYearToMonth& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_Literal_IntervalYearToMonth* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.Literal.IntervalYearToMonth";
+  }
+  protected:
+  explicit Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kYearsFieldNumber = 1,
+    kMonthsFieldNumber = 2,
+  };
+  // int32 years = 1;
+  void clear_years();
+  int32_t years() const;
+  void set_years(int32_t value);
+  private:
+  int32_t _internal_years() const;
+  void _internal_set_years(int32_t value);
+  public:
+
+  // int32 months = 2;
+  void clear_months();
+  int32_t months() const;
+  void set_months(int32_t value);
+  private:
+  int32_t _internal_months() const;
+  void _internal_set_months(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.IntervalYearToMonth)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int32_t years_;
+  int32_t months_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_Literal_IntervalDayToSecond final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.IntervalDayToSecond) */ {
+ public:
+  inline Expression_Literal_IntervalDayToSecond() : Expression_Literal_IntervalDayToSecond(nullptr) {}
+  ~Expression_Literal_IntervalDayToSecond() override;
+  explicit constexpr Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_Literal_IntervalDayToSecond(const Expression_Literal_IntervalDayToSecond& from);
+  Expression_Literal_IntervalDayToSecond(Expression_Literal_IntervalDayToSecond&& from) noexcept
+    : Expression_Literal_IntervalDayToSecond() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_Literal_IntervalDayToSecond& operator=(const Expression_Literal_IntervalDayToSecond& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_Literal_IntervalDayToSecond& operator=(Expression_Literal_IntervalDayToSecond&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_Literal_IntervalDayToSecond& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_Literal_IntervalDayToSecond* internal_default_instance() {
+    return reinterpret_cast<const Expression_Literal_IntervalDayToSecond*>(
+               &_Expression_Literal_IntervalDayToSecond_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(Expression_Literal_IntervalDayToSecond& a, Expression_Literal_IntervalDayToSecond& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_Literal_IntervalDayToSecond* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_Literal_IntervalDayToSecond* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_Literal_IntervalDayToSecond* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_Literal_IntervalDayToSecond>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_Literal_IntervalDayToSecond& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_Literal_IntervalDayToSecond& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_Literal_IntervalDayToSecond* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.Literal.IntervalDayToSecond";
+  }
+  protected:
+  explicit Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDaysFieldNumber = 1,
+    kSecondsFieldNumber = 2,
+  };
+  // int32 days = 1;
+  void clear_days();
+  int32_t days() const;
+  void set_days(int32_t value);
+  private:
+  int32_t _internal_days() const;
+  void _internal_set_days(int32_t value);
+  public:
+
+  // int32 seconds = 2;
+  void clear_seconds();
+  int32_t seconds() const;
+  void set_seconds(int32_t value);
+  private:
+  int32_t _internal_seconds() const;
+  void _internal_set_seconds(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.IntervalDayToSecond)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int32_t days_;
+  int32_t seconds_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_Literal_Struct final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Struct) */ {
+ public:
+  inline Expression_Literal_Struct() : Expression_Literal_Struct(nullptr) {}
+  ~Expression_Literal_Struct() override;
+  explicit constexpr Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_Literal_Struct(const Expression_Literal_Struct& from);
+  Expression_Literal_Struct(Expression_Literal_Struct&& from) noexcept
+    : Expression_Literal_Struct() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_Literal_Struct& operator=(const Expression_Literal_Struct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_Literal_Struct& operator=(Expression_Literal_Struct&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_Literal_Struct& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_Literal_Struct* internal_default_instance() {
+    return reinterpret_cast<const Expression_Literal_Struct*>(
+               &_Expression_Literal_Struct_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(Expression_Literal_Struct& a, Expression_Literal_Struct& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_Literal_Struct* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_Literal_Struct* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_Literal_Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_Literal_Struct>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_Literal_Struct& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_Literal_Struct& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_Literal_Struct* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.Literal.Struct";
+  }
+  protected:
+  explicit Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFieldsFieldNumber = 1,
+  };
+  // repeated .substrait.Expression.Literal fields = 1;
+  int fields_size() const;
+  private:
+  int _internal_fields_size() const;
+  public:
+  void clear_fields();
+  ::substrait::Expression_Literal* mutable_fields(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >*
+      mutable_fields();
+  private:
+  const ::substrait::Expression_Literal& _internal_fields(int index) const;
+  ::substrait::Expression_Literal* _internal_add_fields();
+  public:
+  const ::substrait::Expression_Literal& fields(int index) const;
+  ::substrait::Expression_Literal* add_fields();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >&
+      fields() const;
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Struct)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal > fields_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_Literal_List final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.List) */ {
+ public:
+  inline Expression_Literal_List() : Expression_Literal_List(nullptr) {}
+  ~Expression_Literal_List() override;
+  explicit constexpr Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_Literal_List(const Expression_Literal_List& from);
+  Expression_Literal_List(Expression_Literal_List&& from) noexcept
+    : Expression_Literal_List() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_Literal_List& operator=(const Expression_Literal_List& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_Literal_List& operator=(Expression_Literal_List&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_Literal_List& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_Literal_List* internal_default_instance() {
+    return reinterpret_cast<const Expression_Literal_List*>(
+               &_Expression_Literal_List_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(Expression_Literal_List& a, Expression_Literal_List& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_Literal_List* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_Literal_List* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_Literal_List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_Literal_List>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_Literal_List& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_Literal_List& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_Literal_List* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.Literal.List";
+  }
+  protected:
+  explicit Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValuesFieldNumber = 1,
+  };
+  // repeated .substrait.Expression.Literal values = 1;
+  int values_size() const;
+  private:
+  int _internal_values_size() const;
+  public:
+  void clear_values();
+  ::substrait::Expression_Literal* mutable_values(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >*
+      mutable_values();
+  private:
+  const ::substrait::Expression_Literal& _internal_values(int index) const;
+  ::substrait::Expression_Literal* _internal_add_values();
+  public:
+  const ::substrait::Expression_Literal& values(int index) const;
+  ::substrait::Expression_Literal* add_values();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >&
+      values() const;
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.List)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal > values_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_Literal final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal) */ {
+ public:
+  inline Expression_Literal() : Expression_Literal(nullptr) {}
+  ~Expression_Literal() override;
+  explicit constexpr Expression_Literal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_Literal(const Expression_Literal& from);
+  Expression_Literal(Expression_Literal&& from) noexcept
+    : Expression_Literal() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_Literal& operator=(const Expression_Literal& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_Literal& operator=(Expression_Literal&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_Literal& default_instance() {
+    return *internal_default_instance();
+  }
+  enum LiteralTypeCase {
+    kBoolean = 1,
+    kI8 = 2,
+    kI16 = 3,
+    kI32 = 5,
+    kI64 = 7,
+    kFp32 = 10,
+    kFp64 = 11,
+    kString = 12,
+    kBinary = 13,
+    kTimestamp = 14,
+    kDate = 16,
+    kTime = 17,
+    kIntervalYearToMonth = 19,
+    kIntervalDayToSecond = 20,
+    kFixedChar = 21,
+    kVarChar = 22,
+    kFixedBinary = 23,
+    kDecimal = 24,
+    kStruct = 25,
+    kMap = 26,
+    kTimestampTz = 27,
+    kUuid = 28,
+    kNull = 29,
+    kList = 30,
+    kEmptyList = 31,
+    kEmptyMap = 32,
+    LITERAL_TYPE_NOT_SET = 0,
+  };
+
+  static inline const Expression_Literal* internal_default_instance() {
+    return reinterpret_cast<const Expression_Literal*>(
+               &_Expression_Literal_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(Expression_Literal& a, Expression_Literal& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_Literal* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_Literal* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_Literal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_Literal>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_Literal& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_Literal& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_Literal* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.Literal";
+  }
+  protected:
+  explicit Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_Literal_VarChar VarChar;
+  typedef Expression_Literal_Decimal Decimal;
+  typedef Expression_Literal_Map Map;
+  typedef Expression_Literal_IntervalYearToMonth IntervalYearToMonth;
+  typedef Expression_Literal_IntervalDayToSecond IntervalDayToSecond;
+  typedef Expression_Literal_Struct Struct;
+  typedef Expression_Literal_List List;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNullableFieldNumber = 50,
+    kBooleanFieldNumber = 1,
+    kI8FieldNumber = 2,
+    kI16FieldNumber = 3,
+    kI32FieldNumber = 5,
+    kI64FieldNumber = 7,
+    kFp32FieldNumber = 10,
+    kFp64FieldNumber = 11,
+    kStringFieldNumber = 12,
+    kBinaryFieldNumber = 13,
+    kTimestampFieldNumber = 14,
+    kDateFieldNumber = 16,
+    kTimeFieldNumber = 17,
+    kIntervalYearToMonthFieldNumber = 19,
+    kIntervalDayToSecondFieldNumber = 20,
+    kFixedCharFieldNumber = 21,
+    kVarCharFieldNumber = 22,
+    kFixedBinaryFieldNumber = 23,
+    kDecimalFieldNumber = 24,
+    kStructFieldNumber = 25,
+    kMapFieldNumber = 26,
+    kTimestampTzFieldNumber = 27,
+    kUuidFieldNumber = 28,
+    kNullFieldNumber = 29,
+    kListFieldNumber = 30,
+    kEmptyListFieldNumber = 31,
+    kEmptyMapFieldNumber = 32,
+  };
+  // bool nullable = 50;
+  void clear_nullable();
+  bool nullable() const;
+  void set_nullable(bool value);
+  private:
+  bool _internal_nullable() const;
+  void _internal_set_nullable(bool value);
+  public:
+
+  // bool boolean = 1;
+  bool has_boolean() const;
+  private:
+  bool _internal_has_boolean() const;
+  public:
+  void clear_boolean();
+  bool boolean() const;
+  void set_boolean(bool value);
+  private:
+  bool _internal_boolean() const;
+  void _internal_set_boolean(bool value);
+  public:
+
+  // int32 i8 = 2;
+  bool has_i8() const;
+  private:
+  bool _internal_has_i8() const;
+  public:
+  void clear_i8();
+  int32_t i8() const;
+  void set_i8(int32_t value);
+  private:
+  int32_t _internal_i8() const;
+  void _internal_set_i8(int32_t value);
+  public:
+
+  // int32 i16 = 3;
+  bool has_i16() const;
+  private:
+  bool _internal_has_i16() const;
+  public:
+  void clear_i16();
+  int32_t i16() const;
+  void set_i16(int32_t value);
+  private:
+  int32_t _internal_i16() const;
+  void _internal_set_i16(int32_t value);
+  public:
+
+  // int32 i32 = 5;
+  bool has_i32() const;
+  private:
+  bool _internal_has_i32() const;
+  public:
+  void clear_i32();
+  int32_t i32() const;
+  void set_i32(int32_t value);
+  private:
+  int32_t _internal_i32() const;
+  void _internal_set_i32(int32_t value);
+  public:
+
+  // int64 i64 = 7;
+  bool has_i64() const;
+  private:
+  bool _internal_has_i64() const;
+  public:
+  void clear_i64();
+  int64_t i64() const;
+  void set_i64(int64_t value);
+  private:
+  int64_t _internal_i64() const;
+  void _internal_set_i64(int64_t value);
+  public:
+
+  // float fp32 = 10;
+  bool has_fp32() const;
+  private:
+  bool _internal_has_fp32() const;
+  public:
+  void clear_fp32();
+  float fp32() const;
+  void set_fp32(float value);
+  private:
+  float _internal_fp32() const;
+  void _internal_set_fp32(float value);
+  public:
+
+  // double fp64 = 11;
+  bool has_fp64() const;
+  private:
+  bool _internal_has_fp64() const;
+  public:
+  void clear_fp64();
+  double fp64() const;
+  void set_fp64(double value);
+  private:
+  double _internal_fp64() const;
+  void _internal_set_fp64(double value);
+  public:
+
+  // string string = 12;
+  bool has_string() const;
+  private:
+  bool _internal_has_string() const;
+  public:
+  void clear_string();
+  const std::string& string() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_string(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_string();
+  PROTOBUF_NODISCARD std::string* release_string();
+  void set_allocated_string(std::string* string);
+  private:
+  const std::string& _internal_string() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_string(const std::string& value);
+  std::string* _internal_mutable_string();
+  public:
+
+  // bytes binary = 13;
+  bool has_binary() const;
+  private:
+  bool _internal_has_binary() const;
+  public:
+  void clear_binary();
+  const std::string& binary() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_binary(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_binary();
+  PROTOBUF_NODISCARD std::string* release_binary();
+  void set_allocated_binary(std::string* binary);
+  private:
+  const std::string& _internal_binary() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_binary(const std::string& value);
+  std::string* _internal_mutable_binary();
+  public:
+
+  // int64 timestamp = 14;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  int64_t timestamp() const;
+  void set_timestamp(int64_t value);
+  private:
+  int64_t _internal_timestamp() const;
+  void _internal_set_timestamp(int64_t value);
+  public:
+
+  // int32 date = 16;
+  bool has_date() const;
+  private:
+  bool _internal_has_date() const;
+  public:
+  void clear_date();
+  int32_t date() const;
+  void set_date(int32_t value);
+  private:
+  int32_t _internal_date() const;
+  void _internal_set_date(int32_t value);
+  public:
+
+  // int64 time = 17;
+  bool has_time() const;
+  private:
+  bool _internal_has_time() const;
+  public:
+  void clear_time();
+  int64_t time() const;
+  void set_time(int64_t value);
+  private:
+  int64_t _internal_time() const;
+  void _internal_set_time(int64_t value);
+  public:
+
+  // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19;
+  bool has_interval_year_to_month() const;
+  private:
+  bool _internal_has_interval_year_to_month() const;
+  public:
+  void clear_interval_year_to_month();
+  const ::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Literal_IntervalYearToMonth* release_interval_year_to_month();
+  ::substrait::Expression_Literal_IntervalYearToMonth* mutable_interval_year_to_month();
+  void set_allocated_interval_year_to_month(::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month);
+  private:
+  const ::substrait::Expression_Literal_IntervalYearToMonth& _internal_interval_year_to_month() const;
+  ::substrait::Expression_Literal_IntervalYearToMonth* _internal_mutable_interval_year_to_month();
+  public:
+  void unsafe_arena_set_allocated_interval_year_to_month(
+      ::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month);
+  ::substrait::Expression_Literal_IntervalYearToMonth* unsafe_arena_release_interval_year_to_month();
+
+  // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20;
+  bool has_interval_day_to_second() const;
+  private:
+  bool _internal_has_interval_day_to_second() const;
+  public:
+  void clear_interval_day_to_second();
+  const ::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Literal_IntervalDayToSecond* release_interval_day_to_second();
+  ::substrait::Expression_Literal_IntervalDayToSecond* mutable_interval_day_to_second();
+  void set_allocated_interval_day_to_second(::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second);
+  private:
+  const ::substrait::Expression_Literal_IntervalDayToSecond& _internal_interval_day_to_second() const;
+  ::substrait::Expression_Literal_IntervalDayToSecond* _internal_mutable_interval_day_to_second();
+  public:
+  void unsafe_arena_set_allocated_interval_day_to_second(
+      ::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second);
+  ::substrait::Expression_Literal_IntervalDayToSecond* unsafe_arena_release_interval_day_to_second();
+
+  // string fixed_char = 21;
+  bool has_fixed_char() const;
+  private:
+  bool _internal_has_fixed_char() const;
+  public:
+  void clear_fixed_char();
+  const std::string& fixed_char() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fixed_char(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fixed_char();
+  PROTOBUF_NODISCARD std::string* release_fixed_char();
+  void set_allocated_fixed_char(std::string* fixed_char);
+  private:
+  const std::string& _internal_fixed_char() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fixed_char(const std::string& value);
+  std::string* _internal_mutable_fixed_char();
+  public:
+
+  // .substrait.Expression.Literal.VarChar var_char = 22;
+  bool has_var_char() const;
+  private:
+  bool _internal_has_var_char() const;
+  public:
+  void clear_var_char();
+  const ::substrait::Expression_Literal_VarChar& var_char() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Literal_VarChar* release_var_char();
+  ::substrait::Expression_Literal_VarChar* mutable_var_char();
+  void set_allocated_var_char(::substrait::Expression_Literal_VarChar* var_char);
+  private:
+  const ::substrait::Expression_Literal_VarChar& _internal_var_char() const;
+  ::substrait::Expression_Literal_VarChar* _internal_mutable_var_char();
+  public:
+  void unsafe_arena_set_allocated_var_char(
+      ::substrait::Expression_Literal_VarChar* var_char);
+  ::substrait::Expression_Literal_VarChar* unsafe_arena_release_var_char();
+
+  // bytes fixed_binary = 23;
+  bool has_fixed_binary() const;
+  private:
+  bool _internal_has_fixed_binary() const;
+  public:
+  void clear_fixed_binary();
+  const std::string& fixed_binary() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_fixed_binary(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_fixed_binary();
+  PROTOBUF_NODISCARD std::string* release_fixed_binary();
+  void set_allocated_fixed_binary(std::string* fixed_binary);
+  private:
+  const std::string& _internal_fixed_binary() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fixed_binary(const std::string& value);
+  std::string* _internal_mutable_fixed_binary();
+  public:
+
+  // .substrait.Expression.Literal.Decimal decimal = 24;
+  bool has_decimal() const;
+  private:
+  bool _internal_has_decimal() const;
+  public:
+  void clear_decimal();
+  const ::substrait::Expression_Literal_Decimal& decimal() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Literal_Decimal* release_decimal();
+  ::substrait::Expression_Literal_Decimal* mutable_decimal();
+  void set_allocated_decimal(::substrait::Expression_Literal_Decimal* decimal);
+  private:
+  const ::substrait::Expression_Literal_Decimal& _internal_decimal() const;
+  ::substrait::Expression_Literal_Decimal* _internal_mutable_decimal();
+  public:
+  void unsafe_arena_set_allocated_decimal(
+      ::substrait::Expression_Literal_Decimal* decimal);
+  ::substrait::Expression_Literal_Decimal* unsafe_arena_release_decimal();
+
+  // .substrait.Expression.Literal.Struct struct = 25;
+  bool has_struct_() const;
+  private:
+  bool _internal_has_struct_() const;
+  public:
+  void clear_struct_();
+  const ::substrait::Expression_Literal_Struct& struct_() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Literal_Struct* release_struct_();
+  ::substrait::Expression_Literal_Struct* mutable_struct_();
+  void set_allocated_struct_(::substrait::Expression_Literal_Struct* struct_);
+  private:
+  const ::substrait::Expression_Literal_Struct& _internal_struct_() const;
+  ::substrait::Expression_Literal_Struct* _internal_mutable_struct_();
+  public:
+  void unsafe_arena_set_allocated_struct_(
+      ::substrait::Expression_Literal_Struct* struct_);
+  ::substrait::Expression_Literal_Struct* unsafe_arena_release_struct_();
+
+  // .substrait.Expression.Literal.Map map = 26;
+  bool has_map() const;
+  private:
+  bool _internal_has_map() const;
+  public:
+  void clear_map();
+  const ::substrait::Expression_Literal_Map& map() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Literal_Map* release_map();
+  ::substrait::Expression_Literal_Map* mutable_map();
+  void set_allocated_map(::substrait::Expression_Literal_Map* map);
+  private:
+  const ::substrait::Expression_Literal_Map& _internal_map() const;
+  ::substrait::Expression_Literal_Map* _internal_mutable_map();
+  public:
+  void unsafe_arena_set_allocated_map(
+      ::substrait::Expression_Literal_Map* map);
+  ::substrait::Expression_Literal_Map* unsafe_arena_release_map();
+
+  // int64 timestamp_tz = 27;
+  bool has_timestamp_tz() const;
+  private:
+  bool _internal_has_timestamp_tz() const;
+  public:
+  void clear_timestamp_tz();
+  int64_t timestamp_tz() const;
+  void set_timestamp_tz(int64_t value);
+  private:
+  int64_t _internal_timestamp_tz() const;
+  void _internal_set_timestamp_tz(int64_t value);
+  public:
+
+  // bytes uuid = 28;
+  bool has_uuid() const;
+  private:
+  bool _internal_has_uuid() const;
+  public:
+  void clear_uuid();
+  const std::string& uuid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_uuid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_uuid();
+  PROTOBUF_NODISCARD std::string* release_uuid();
+  void set_allocated_uuid(std::string* uuid);
+  private:
+  const std::string& _internal_uuid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uuid(const std::string& value);
+  std::string* _internal_mutable_uuid();
+  public:
+
+  // .substrait.Type null = 29;
+  bool has_null() const;
+  private:
+  bool _internal_has_null() const;
+  public:
+  void clear_null();
+  const ::substrait::Type& null() const;
+  PROTOBUF_NODISCARD ::substrait::Type* release_null();
+  ::substrait::Type* mutable_null();
+  void set_allocated_null(::substrait::Type* null);
+  private:
+  const ::substrait::Type& _internal_null() const;
+  ::substrait::Type* _internal_mutable_null();
+  public:
+  void unsafe_arena_set_allocated_null(
+      ::substrait::Type* null);
+  ::substrait::Type* unsafe_arena_release_null();
+
+  // .substrait.Expression.Literal.List list = 30;
+  bool has_list() const;
+  private:
+  bool _internal_has_list() const;
+  public:
+  void clear_list();
+  const ::substrait::Expression_Literal_List& list() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Literal_List* release_list();
+  ::substrait::Expression_Literal_List* mutable_list();
+  void set_allocated_list(::substrait::Expression_Literal_List* list);
+  private:
+  const ::substrait::Expression_Literal_List& _internal_list() const;
+  ::substrait::Expression_Literal_List* _internal_mutable_list();
+  public:
+  void unsafe_arena_set_allocated_list(
+      ::substrait::Expression_Literal_List* list);
+  ::substrait::Expression_Literal_List* unsafe_arena_release_list();
+
+  // .substrait.Type.List empty_list = 31;
+  bool has_empty_list() const;
+  private:
+  bool _internal_has_empty_list() const;
+  public:
+  void clear_empty_list();
+  const ::substrait::Type_List& empty_list() const;
+  PROTOBUF_NODISCARD ::substrait::Type_List* release_empty_list();
+  ::substrait::Type_List* mutable_empty_list();
+  void set_allocated_empty_list(::substrait::Type_List* empty_list);
+  private:
+  const ::substrait::Type_List& _internal_empty_list() const;
+  ::substrait::Type_List* _internal_mutable_empty_list();
+  public:
+  void unsafe_arena_set_allocated_empty_list(
+      ::substrait::Type_List* empty_list);
+  ::substrait::Type_List* unsafe_arena_release_empty_list();
+
+  // .substrait.Type.Map empty_map = 32;
+  bool has_empty_map() const;
+  private:
+  bool _internal_has_empty_map() const;
+  public:
+  void clear_empty_map();
+  const ::substrait::Type_Map& empty_map() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Map* release_empty_map();
+  ::substrait::Type_Map* mutable_empty_map();
+  void set_allocated_empty_map(::substrait::Type_Map* empty_map);
+  private:
+  const ::substrait::Type_Map& _internal_empty_map() const;
+  ::substrait::Type_Map* _internal_mutable_empty_map();
+  public:
+  void unsafe_arena_set_allocated_empty_map(
+      ::substrait::Type_Map* empty_map);
+  ::substrait::Type_Map* unsafe_arena_release_empty_map();
+
+  void clear_literal_type();
+  LiteralTypeCase literal_type_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.Expression.Literal)
+ private:
+  class _Internal;
+  void set_has_boolean();
+  void set_has_i8();
+  void set_has_i16();
+  void set_has_i32();
+  void set_has_i64();
+  void set_has_fp32();
+  void set_has_fp64();
+  void set_has_string();
+  void set_has_binary();
+  void set_has_timestamp();
+  void set_has_date();
+  void set_has_time();
+  void set_has_interval_year_to_month();
+  void set_has_interval_day_to_second();
+  void set_has_fixed_char();
+  void set_has_var_char();
+  void set_has_fixed_binary();
+  void set_has_decimal();
+  void set_has_struct_();
+  void set_has_map();
+  void set_has_timestamp_tz();
+  void set_has_uuid();
+  void set_has_null();
+  void set_has_list();
+  void set_has_empty_list();
+  void set_has_empty_map();
+
+  inline bool has_literal_type() const;
+  inline void clear_has_literal_type();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  bool nullable_;
+  union LiteralTypeUnion {
+    constexpr LiteralTypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    bool boolean_;
+    int32_t i8_;
+    int32_t i16_;
+    int32_t i32_;
+    int64_t i64_;
+    float fp32_;
+    double fp64_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_;
+    int64_t timestamp_;
+    int32_t date_;
+    int64_t time_;
+    ::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month_;
+    ::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fixed_char_;
+    ::substrait::Expression_Literal_VarChar* var_char_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fixed_binary_;
+    ::substrait::Expression_Literal_Decimal* decimal_;
+    ::substrait::Expression_Literal_Struct* struct__;
+    ::substrait::Expression_Literal_Map* map_;
+    int64_t timestamp_tz_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uuid_;
+    ::substrait::Type* null_;
+    ::substrait::Expression_Literal_List* list_;
+    ::substrait::Type_List* empty_list_;
+    ::substrait::Type_Map* empty_map_;
+  } literal_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_ScalarFunction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ScalarFunction) */ {
+ public:
+  inline Expression_ScalarFunction() : Expression_ScalarFunction(nullptr) {}
+  ~Expression_ScalarFunction() override;
+  explicit constexpr Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_ScalarFunction(const Expression_ScalarFunction& from);
+  Expression_ScalarFunction(Expression_ScalarFunction&& from) noexcept
+    : Expression_ScalarFunction() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_ScalarFunction& operator=(const Expression_ScalarFunction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_ScalarFunction& operator=(Expression_ScalarFunction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_ScalarFunction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_ScalarFunction* internal_default_instance() {
+    return reinterpret_cast<const Expression_ScalarFunction*>(
+               &_Expression_ScalarFunction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(Expression_ScalarFunction& a, Expression_ScalarFunction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_ScalarFunction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_ScalarFunction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_ScalarFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_ScalarFunction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_ScalarFunction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_ScalarFunction& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_ScalarFunction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.ScalarFunction";
+  }
+  protected:
+  explicit Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kArgsFieldNumber = 2,
+    kOutputTypeFieldNumber = 3,
+    kFunctionReferenceFieldNumber = 1,
+  };
+  // repeated .substrait.Expression args = 2;
+  int args_size() const;
+  private:
+  int _internal_args_size() const;
+  public:
+  void clear_args();
+  ::substrait::Expression* mutable_args(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+      mutable_args();
+  private:
+  const ::substrait::Expression& _internal_args(int index) const;
+  ::substrait::Expression* _internal_add_args();
+  public:
+  const ::substrait::Expression& args(int index) const;
+  ::substrait::Expression* add_args();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+      args() const;
+
+  // .substrait.Type output_type = 3;
+  bool has_output_type() const;
+  private:
+  bool _internal_has_output_type() const;
+  public:
+  void clear_output_type();
+  const ::substrait::Type& output_type() const;
+  PROTOBUF_NODISCARD ::substrait::Type* release_output_type();
+  ::substrait::Type* mutable_output_type();
+  void set_allocated_output_type(::substrait::Type* output_type);
+  private:
+  const ::substrait::Type& _internal_output_type() const;
+  ::substrait::Type* _internal_mutable_output_type();
+  public:
+  void unsafe_arena_set_allocated_output_type(
+      ::substrait::Type* output_type);
+  ::substrait::Type* unsafe_arena_release_output_type();
+
+  // uint32 function_reference = 1;
+  void clear_function_reference();
+  uint32_t function_reference() const;
+  void set_function_reference(uint32_t value);
+  private:
+  uint32_t _internal_function_reference() const;
+  void _internal_set_function_reference(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.ScalarFunction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > args_;
+  ::substrait::Type* output_type_;
+  uint32_t function_reference_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_WindowFunction_Bound_Preceding final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Preceding) */ {
+ public:
+  inline Expression_WindowFunction_Bound_Preceding() : Expression_WindowFunction_Bound_Preceding(nullptr) {}
+  ~Expression_WindowFunction_Bound_Preceding() override;
+  explicit constexpr Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_WindowFunction_Bound_Preceding(const Expression_WindowFunction_Bound_Preceding& from);
+  Expression_WindowFunction_Bound_Preceding(Expression_WindowFunction_Bound_Preceding&& from) noexcept
+    : Expression_WindowFunction_Bound_Preceding() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_WindowFunction_Bound_Preceding& operator=(const Expression_WindowFunction_Bound_Preceding& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_WindowFunction_Bound_Preceding& operator=(Expression_WindowFunction_Bound_Preceding&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_WindowFunction_Bound_Preceding& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_WindowFunction_Bound_Preceding* internal_default_instance() {
+    return reinterpret_cast<const Expression_WindowFunction_Bound_Preceding*>(
+               &_Expression_WindowFunction_Bound_Preceding_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(Expression_WindowFunction_Bound_Preceding& a, Expression_WindowFunction_Bound_Preceding& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_WindowFunction_Bound_Preceding* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_WindowFunction_Bound_Preceding* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_WindowFunction_Bound_Preceding* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_WindowFunction_Bound_Preceding>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_WindowFunction_Bound_Preceding& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_WindowFunction_Bound_Preceding& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_WindowFunction_Bound_Preceding* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.WindowFunction.Bound.Preceding";
+  }
+  protected:
+  explicit Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOffsetFieldNumber = 1,
+  };
+  // int64 offset = 1;
+  void clear_offset();
+  int64_t offset() const;
+  void set_offset(int64_t value);
+  private:
+  int64_t _internal_offset() const;
+  void _internal_set_offset(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.Preceding)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int64_t offset_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_WindowFunction_Bound_Following final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Following) */ {
+ public:
+  inline Expression_WindowFunction_Bound_Following() : Expression_WindowFunction_Bound_Following(nullptr) {}
+  ~Expression_WindowFunction_Bound_Following() override;
+  explicit constexpr Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_WindowFunction_Bound_Following(const Expression_WindowFunction_Bound_Following& from);
+  Expression_WindowFunction_Bound_Following(Expression_WindowFunction_Bound_Following&& from) noexcept
+    : Expression_WindowFunction_Bound_Following() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_WindowFunction_Bound_Following& operator=(const Expression_WindowFunction_Bound_Following& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_WindowFunction_Bound_Following& operator=(Expression_WindowFunction_Bound_Following&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_WindowFunction_Bound_Following& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_WindowFunction_Bound_Following* internal_default_instance() {
+    return reinterpret_cast<const Expression_WindowFunction_Bound_Following*>(
+               &_Expression_WindowFunction_Bound_Following_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(Expression_WindowFunction_Bound_Following& a, Expression_WindowFunction_Bound_Following& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_WindowFunction_Bound_Following* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_WindowFunction_Bound_Following* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_WindowFunction_Bound_Following* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_WindowFunction_Bound_Following>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_WindowFunction_Bound_Following& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_WindowFunction_Bound_Following& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_WindowFunction_Bound_Following* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.WindowFunction.Bound.Following";
+  }
+  protected:
+  explicit Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOffsetFieldNumber = 1,
+  };
+  // int64 offset = 1;
+  void clear_offset();
+  int64_t offset() const;
+  void set_offset(int64_t value);
+  private:
+  int64_t _internal_offset() const;
+  void _internal_set_offset(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.Following)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int64_t offset_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_WindowFunction_Bound_CurrentRow final :
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.CurrentRow) */ {
+ public:
+  inline Expression_WindowFunction_Bound_CurrentRow() : Expression_WindowFunction_Bound_CurrentRow(nullptr) {}
+  explicit constexpr Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_WindowFunction_Bound_CurrentRow(const Expression_WindowFunction_Bound_CurrentRow& from);
+  Expression_WindowFunction_Bound_CurrentRow(Expression_WindowFunction_Bound_CurrentRow&& from) noexcept
+    : Expression_WindowFunction_Bound_CurrentRow() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_WindowFunction_Bound_CurrentRow& operator=(const Expression_WindowFunction_Bound_CurrentRow& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_WindowFunction_Bound_CurrentRow& operator=(Expression_WindowFunction_Bound_CurrentRow&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_WindowFunction_Bound_CurrentRow& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_WindowFunction_Bound_CurrentRow* internal_default_instance() {
+    return reinterpret_cast<const Expression_WindowFunction_Bound_CurrentRow*>(
+               &_Expression_WindowFunction_Bound_CurrentRow_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(Expression_WindowFunction_Bound_CurrentRow& a, Expression_WindowFunction_Bound_CurrentRow& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_WindowFunction_Bound_CurrentRow* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_WindowFunction_Bound_CurrentRow* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_WindowFunction_Bound_CurrentRow* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_WindowFunction_Bound_CurrentRow>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
+  inline void CopyFrom(const Expression_WindowFunction_Bound_CurrentRow& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
+  void MergeFrom(const Expression_WindowFunction_Bound_CurrentRow& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
+  }
+  public:
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.WindowFunction.Bound.CurrentRow";
+  }
+  protected:
+  explicit Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.CurrentRow)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_WindowFunction_Bound_Unbounded final :
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Unbounded) */ {
+ public:
+  inline Expression_WindowFunction_Bound_Unbounded() : Expression_WindowFunction_Bound_Unbounded(nullptr) {}
+  explicit constexpr Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_WindowFunction_Bound_Unbounded(const Expression_WindowFunction_Bound_Unbounded& from);
+  Expression_WindowFunction_Bound_Unbounded(Expression_WindowFunction_Bound_Unbounded&& from) noexcept
+    : Expression_WindowFunction_Bound_Unbounded() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_WindowFunction_Bound_Unbounded& operator=(const Expression_WindowFunction_Bound_Unbounded& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_WindowFunction_Bound_Unbounded& operator=(Expression_WindowFunction_Bound_Unbounded&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_WindowFunction_Bound_Unbounded& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_WindowFunction_Bound_Unbounded* internal_default_instance() {
+    return reinterpret_cast<const Expression_WindowFunction_Bound_Unbounded*>(
+               &_Expression_WindowFunction_Bound_Unbounded_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(Expression_WindowFunction_Bound_Unbounded& a, Expression_WindowFunction_Bound_Unbounded& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_WindowFunction_Bound_Unbounded* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_WindowFunction_Bound_Unbounded* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_WindowFunction_Bound_Unbounded* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_WindowFunction_Bound_Unbounded>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
+  inline void CopyFrom(const Expression_WindowFunction_Bound_Unbounded& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
+  void MergeFrom(const Expression_WindowFunction_Bound_Unbounded& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
+  }
+  public:
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.WindowFunction.Bound.Unbounded";
+  }
+  protected:
+  explicit Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.Unbounded)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_WindowFunction_Bound final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound) */ {
+ public:
+  inline Expression_WindowFunction_Bound() : Expression_WindowFunction_Bound(nullptr) {}
+  ~Expression_WindowFunction_Bound() override;
+  explicit constexpr Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_WindowFunction_Bound(const Expression_WindowFunction_Bound& from);
+  Expression_WindowFunction_Bound(Expression_WindowFunction_Bound&& from) noexcept
+    : Expression_WindowFunction_Bound() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_WindowFunction_Bound& operator=(const Expression_WindowFunction_Bound& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_WindowFunction_Bound& operator=(Expression_WindowFunction_Bound&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_WindowFunction_Bound& default_instance() {
+    return *internal_default_instance();
+  }
+  enum KindCase {
+    kPreceding = 1,
+    kFollowing = 2,
+    kCurrentRow = 3,
+    kUnbounded = 4,
+    KIND_NOT_SET = 0,
+  };
+
+  static inline const Expression_WindowFunction_Bound* internal_default_instance() {
+    return reinterpret_cast<const Expression_WindowFunction_Bound*>(
+               &_Expression_WindowFunction_Bound_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(Expression_WindowFunction_Bound& a, Expression_WindowFunction_Bound& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_WindowFunction_Bound* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_WindowFunction_Bound* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_WindowFunction_Bound* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_WindowFunction_Bound>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_WindowFunction_Bound& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_WindowFunction_Bound& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_WindowFunction_Bound* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.WindowFunction.Bound";
+  }
+  protected:
+  explicit Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_WindowFunction_Bound_Preceding Preceding;
+  typedef Expression_WindowFunction_Bound_Following Following;
+  typedef Expression_WindowFunction_Bound_CurrentRow CurrentRow;
+  typedef Expression_WindowFunction_Bound_Unbounded Unbounded;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPrecedingFieldNumber = 1,
+    kFollowingFieldNumber = 2,
+    kCurrentRowFieldNumber = 3,
+    kUnboundedFieldNumber = 4,
+  };
+  // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1;
+  bool has_preceding() const;
+  private:
+  bool _internal_has_preceding() const;
+  public:
+  void clear_preceding();
+  const ::substrait::Expression_WindowFunction_Bound_Preceding& preceding() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound_Preceding* release_preceding();
+  ::substrait::Expression_WindowFunction_Bound_Preceding* mutable_preceding();
+  void set_allocated_preceding(::substrait::Expression_WindowFunction_Bound_Preceding* preceding);
+  private:
+  const ::substrait::Expression_WindowFunction_Bound_Preceding& _internal_preceding() const;
+  ::substrait::Expression_WindowFunction_Bound_Preceding* _internal_mutable_preceding();
+  public:
+  void unsafe_arena_set_allocated_preceding(
+      ::substrait::Expression_WindowFunction_Bound_Preceding* preceding);
+  ::substrait::Expression_WindowFunction_Bound_Preceding* unsafe_arena_release_preceding();
+
+  // .substrait.Expression.WindowFunction.Bound.Following following = 2;
+  bool has_following() const;
+  private:
+  bool _internal_has_following() const;
+  public:
+  void clear_following();
+  const ::substrait::Expression_WindowFunction_Bound_Following& following() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound_Following* release_following();
+  ::substrait::Expression_WindowFunction_Bound_Following* mutable_following();
+  void set_allocated_following(::substrait::Expression_WindowFunction_Bound_Following* following);
+  private:
+  const ::substrait::Expression_WindowFunction_Bound_Following& _internal_following() const;
+  ::substrait::Expression_WindowFunction_Bound_Following* _internal_mutable_following();
+  public:
+  void unsafe_arena_set_allocated_following(
+      ::substrait::Expression_WindowFunction_Bound_Following* following);
+  ::substrait::Expression_WindowFunction_Bound_Following* unsafe_arena_release_following();
+
+  // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3;
+  bool has_current_row() const;
+  private:
+  bool _internal_has_current_row() const;
+  public:
+  void clear_current_row();
+  const ::substrait::Expression_WindowFunction_Bound_CurrentRow& current_row() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound_CurrentRow* release_current_row();
+  ::substrait::Expression_WindowFunction_Bound_CurrentRow* mutable_current_row();
+  void set_allocated_current_row(::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row);
+  private:
+  const ::substrait::Expression_WindowFunction_Bound_CurrentRow& _internal_current_row() const;
+  ::substrait::Expression_WindowFunction_Bound_CurrentRow* _internal_mutable_current_row();
+  public:
+  void unsafe_arena_set_allocated_current_row(
+      ::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row);
+  ::substrait::Expression_WindowFunction_Bound_CurrentRow* unsafe_arena_release_current_row();
+
+  // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4;
+  bool has_unbounded() const;
+  private:
+  bool _internal_has_unbounded() const;
+  public:
+  void clear_unbounded();
+  const ::substrait::Expression_WindowFunction_Bound_Unbounded& unbounded() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound_Unbounded* release_unbounded();
+  ::substrait::Expression_WindowFunction_Bound_Unbounded* mutable_unbounded();
+  void set_allocated_unbounded(::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded);
+  private:
+  const ::substrait::Expression_WindowFunction_Bound_Unbounded& _internal_unbounded() const;
+  ::substrait::Expression_WindowFunction_Bound_Unbounded* _internal_mutable_unbounded();
+  public:
+  void unsafe_arena_set_allocated_unbounded(
+      ::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded);
+  ::substrait::Expression_WindowFunction_Bound_Unbounded* unsafe_arena_release_unbounded();
+
+  void clear_kind();
+  KindCase kind_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound)
+ private:
+  class _Internal;
+  void set_has_preceding();
+  void set_has_following();
+  void set_has_current_row();
+  void set_has_unbounded();
+
+  inline bool has_kind() const;
+  inline void clear_has_kind();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union KindUnion {
+    constexpr KindUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Expression_WindowFunction_Bound_Preceding* preceding_;
+    ::substrait::Expression_WindowFunction_Bound_Following* following_;
+    ::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row_;
+    ::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded_;
+  } kind_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_WindowFunction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction) */ {
+ public:
+  inline Expression_WindowFunction() : Expression_WindowFunction(nullptr) {}
+  ~Expression_WindowFunction() override;
+  explicit constexpr Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_WindowFunction(const Expression_WindowFunction& from);
+  Expression_WindowFunction(Expression_WindowFunction&& from) noexcept
+    : Expression_WindowFunction() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_WindowFunction& operator=(const Expression_WindowFunction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_WindowFunction& operator=(Expression_WindowFunction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_WindowFunction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_WindowFunction* internal_default_instance() {
+    return reinterpret_cast<const Expression_WindowFunction*>(
+               &_Expression_WindowFunction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(Expression_WindowFunction& a, Expression_WindowFunction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_WindowFunction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_WindowFunction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_WindowFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_WindowFunction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_WindowFunction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_WindowFunction& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_WindowFunction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.WindowFunction";
+  }
+  protected:
+  explicit Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_WindowFunction_Bound Bound;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPartitionsFieldNumber = 2,
+    kSortsFieldNumber = 3,
+    kArgsFieldNumber = 8,
+    kUpperBoundFieldNumber = 4,
+    kLowerBoundFieldNumber = 5,
+    kOutputTypeFieldNumber = 7,
+    kFunctionReferenceFieldNumber = 1,
+    kPhaseFieldNumber = 6,
+  };
+  // repeated .substrait.Expression partitions = 2;
+  int partitions_size() const;
+  private:
+  int _internal_partitions_size() const;
+  public:
+  void clear_partitions();
+  ::substrait::Expression* mutable_partitions(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+      mutable_partitions();
+  private:
+  const ::substrait::Expression& _internal_partitions(int index) const;
+  ::substrait::Expression* _internal_add_partitions();
+  public:
+  const ::substrait::Expression& partitions(int index) const;
+  ::substrait::Expression* add_partitions();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+      partitions() const;
+
+  // repeated .substrait.SortField sorts = 3;
+  int sorts_size() const;
+  private:
+  int _internal_sorts_size() const;
+  public:
+  void clear_sorts();
+  ::substrait::SortField* mutable_sorts(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >*
+      mutable_sorts();
+  private:
+  const ::substrait::SortField& _internal_sorts(int index) const;
+  ::substrait::SortField* _internal_add_sorts();
+  public:
+  const ::substrait::SortField& sorts(int index) const;
+  ::substrait::SortField* add_sorts();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >&
+      sorts() const;
+
+  // repeated .substrait.Expression args = 8;
+  int args_size() const;
+  private:
+  int _internal_args_size() const;
+  public:
+  void clear_args();
+  ::substrait::Expression* mutable_args(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+      mutable_args();
+  private:
+  const ::substrait::Expression& _internal_args(int index) const;
+  ::substrait::Expression* _internal_add_args();
+  public:
+  const ::substrait::Expression& args(int index) const;
+  ::substrait::Expression* add_args();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+      args() const;
+
+  // .substrait.Expression.WindowFunction.Bound upper_bound = 4;
+  bool has_upper_bound() const;
+  private:
+  bool _internal_has_upper_bound() const;
+  public:
+  void clear_upper_bound();
+  const ::substrait::Expression_WindowFunction_Bound& upper_bound() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound* release_upper_bound();
+  ::substrait::Expression_WindowFunction_Bound* mutable_upper_bound();
+  void set_allocated_upper_bound(::substrait::Expression_WindowFunction_Bound* upper_bound);
+  private:
+  const ::substrait::Expression_WindowFunction_Bound& _internal_upper_bound() const;
+  ::substrait::Expression_WindowFunction_Bound* _internal_mutable_upper_bound();
+  public:
+  void unsafe_arena_set_allocated_upper_bound(
+      ::substrait::Expression_WindowFunction_Bound* upper_bound);
+  ::substrait::Expression_WindowFunction_Bound* unsafe_arena_release_upper_bound();
+
+  // .substrait.Expression.WindowFunction.Bound lower_bound = 5;
+  bool has_lower_bound() const;
+  private:
+  bool _internal_has_lower_bound() const;
+  public:
+  void clear_lower_bound();
+  const ::substrait::Expression_WindowFunction_Bound& lower_bound() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound* release_lower_bound();
+  ::substrait::Expression_WindowFunction_Bound* mutable_lower_bound();
+  void set_allocated_lower_bound(::substrait::Expression_WindowFunction_Bound* lower_bound);
+  private:
+  const ::substrait::Expression_WindowFunction_Bound& _internal_lower_bound() const;
+  ::substrait::Expression_WindowFunction_Bound* _internal_mutable_lower_bound();
+  public:
+  void unsafe_arena_set_allocated_lower_bound(
+      ::substrait::Expression_WindowFunction_Bound* lower_bound);
+  ::substrait::Expression_WindowFunction_Bound* unsafe_arena_release_lower_bound();
+
+  // .substrait.Type output_type = 7;
+  bool has_output_type() const;
+  private:
+  bool _internal_has_output_type() const;
+  public:
+  void clear_output_type();
+  const ::substrait::Type& output_type() const;
+  PROTOBUF_NODISCARD ::substrait::Type* release_output_type();
+  ::substrait::Type* mutable_output_type();
+  void set_allocated_output_type(::substrait::Type* output_type);
+  private:
+  const ::substrait::Type& _internal_output_type() const;
+  ::substrait::Type* _internal_mutable_output_type();
+  public:
+  void unsafe_arena_set_allocated_output_type(
+      ::substrait::Type* output_type);
+  ::substrait::Type* unsafe_arena_release_output_type();
+
+  // uint32 function_reference = 1;
+  void clear_function_reference();
+  uint32_t function_reference() const;
+  void set_function_reference(uint32_t value);
+  private:
+  uint32_t _internal_function_reference() const;
+  void _internal_set_function_reference(uint32_t value);
+  public:
+
+  // .substrait.AggregationPhase phase = 6;
+  void clear_phase();
+  ::substrait::AggregationPhase phase() const;
+  void set_phase(::substrait::AggregationPhase value);
+  private:
+  ::substrait::AggregationPhase _internal_phase() const;
+  void _internal_set_phase(::substrait::AggregationPhase value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > partitions_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField > sorts_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > args_;
+  ::substrait::Expression_WindowFunction_Bound* upper_bound_;
+  ::substrait::Expression_WindowFunction_Bound* lower_bound_;
+  ::substrait::Type* output_type_;
+  uint32_t function_reference_;
+  int phase_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_IfThen_IfClause final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.IfThen.IfClause) */ {
+ public:
+  inline Expression_IfThen_IfClause() : Expression_IfThen_IfClause(nullptr) {}
+  ~Expression_IfThen_IfClause() override;
+  explicit constexpr Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from);
+  Expression_IfThen_IfClause(Expression_IfThen_IfClause&& from) noexcept
+    : Expression_IfThen_IfClause() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_IfThen_IfClause& operator=(const Expression_IfThen_IfClause& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_IfThen_IfClause& operator=(Expression_IfThen_IfClause&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_IfThen_IfClause& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_IfThen_IfClause* internal_default_instance() {
+    return reinterpret_cast<const Expression_IfThen_IfClause*>(
+               &_Expression_IfThen_IfClause_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(Expression_IfThen_IfClause& a, Expression_IfThen_IfClause& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_IfThen_IfClause* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_IfThen_IfClause* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_IfThen_IfClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_IfThen_IfClause>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_IfThen_IfClause& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_IfThen_IfClause& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_IfThen_IfClause* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.IfThen.IfClause";
+  }
+  protected:
+  explicit Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIfFieldNumber = 1,
+    kThenFieldNumber = 2,
+  };
+  // .substrait.Expression if = 1;
+  bool has_if_() const;
+  private:
+  bool _internal_has_if_() const;
+  public:
+  void clear_if_();
+  const ::substrait::Expression& if_() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_if_();
+  ::substrait::Expression* mutable_if_();
+  void set_allocated_if_(::substrait::Expression* if_);
+  private:
+  const ::substrait::Expression& _internal_if_() const;
+  ::substrait::Expression* _internal_mutable_if_();
+  public:
+  void unsafe_arena_set_allocated_if_(
+      ::substrait::Expression* if_);
+  ::substrait::Expression* unsafe_arena_release_if_();
+
+  // .substrait.Expression then = 2;
+  bool has_then() const;
+  private:
+  bool _internal_has_then() const;
+  public:
+  void clear_then();
+  const ::substrait::Expression& then() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_then();
+  ::substrait::Expression* mutable_then();
+  void set_allocated_then(::substrait::Expression* then);
+  private:
+  const ::substrait::Expression& _internal_then() const;
+  ::substrait::Expression* _internal_mutable_then();
+  public:
+  void unsafe_arena_set_allocated_then(
+      ::substrait::Expression* then);
+  ::substrait::Expression* unsafe_arena_release_then();
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.IfThen.IfClause)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Expression* if__;
+  ::substrait::Expression* then_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_IfThen final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.IfThen) */ {
+ public:
+  inline Expression_IfThen() : Expression_IfThen(nullptr) {}
+  ~Expression_IfThen() override;
+  explicit constexpr Expression_IfThen(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_IfThen(const Expression_IfThen& from);
+  Expression_IfThen(Expression_IfThen&& from) noexcept
+    : Expression_IfThen() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_IfThen& operator=(const Expression_IfThen& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_IfThen& operator=(Expression_IfThen&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_IfThen& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_IfThen* internal_default_instance() {
+    return reinterpret_cast<const Expression_IfThen*>(
+               &_Expression_IfThen_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  friend void swap(Expression_IfThen& a, Expression_IfThen& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_IfThen* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_IfThen* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_IfThen* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_IfThen>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_IfThen& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_IfThen& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_IfThen* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.IfThen";
+  }
+  protected:
+  explicit Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_IfThen_IfClause IfClause;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIfsFieldNumber = 1,
+    kElseFieldNumber = 2,
+  };
+  // repeated .substrait.Expression.IfThen.IfClause ifs = 1;
+  int ifs_size() const;
+  private:
+  int _internal_ifs_size() const;
+  public:
+  void clear_ifs();
+  ::substrait::Expression_IfThen_IfClause* mutable_ifs(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >*
+      mutable_ifs();
+  private:
+  const ::substrait::Expression_IfThen_IfClause& _internal_ifs(int index) const;
+  ::substrait::Expression_IfThen_IfClause* _internal_add_ifs();
+  public:
+  const ::substrait::Expression_IfThen_IfClause& ifs(int index) const;
+  ::substrait::Expression_IfThen_IfClause* add_ifs();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >&
+      ifs() const;
+
+  // .substrait.Expression else = 2;
+  bool has_else_() const;
+  private:
+  bool _internal_has_else_() const;
+  public:
+  void clear_else_();
+  const ::substrait::Expression& else_() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_else_();
+  ::substrait::Expression* mutable_else_();
+  void set_allocated_else_(::substrait::Expression* else_);
+  private:
+  const ::substrait::Expression& _internal_else_() const;
+  ::substrait::Expression* _internal_mutable_else_();
+  public:
+  void unsafe_arena_set_allocated_else_(
+      ::substrait::Expression* else_);
+  ::substrait::Expression* unsafe_arena_release_else_();
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.IfThen)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause > ifs_;
+  ::substrait::Expression* else__;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_Cast final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Cast) */ {
+ public:
+  inline Expression_Cast() : Expression_Cast(nullptr) {}
+  ~Expression_Cast() override;
+  explicit constexpr Expression_Cast(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_Cast(const Expression_Cast& from);
+  Expression_Cast(Expression_Cast&& from) noexcept
+    : Expression_Cast() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_Cast& operator=(const Expression_Cast& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_Cast& operator=(Expression_Cast&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_Cast& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_Cast* internal_default_instance() {
+    return reinterpret_cast<const Expression_Cast*>(
+               &_Expression_Cast_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  friend void swap(Expression_Cast& a, Expression_Cast& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_Cast* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_Cast* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_Cast* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_Cast>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_Cast& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_Cast& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_Cast* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.Cast";
+  }
+  protected:
+  explicit Expression_Cast(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeFieldNumber = 1,
+    kInputFieldNumber = 2,
+  };
+  // .substrait.Type type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  const ::substrait::Type& type() const;
+  PROTOBUF_NODISCARD ::substrait::Type* release_type();
+  ::substrait::Type* mutable_type();
+  void set_allocated_type(::substrait::Type* type);
+  private:
+  const ::substrait::Type& _internal_type() const;
+  ::substrait::Type* _internal_mutable_type();
+  public:
+  void unsafe_arena_set_allocated_type(
+      ::substrait::Type* type);
+  ::substrait::Type* unsafe_arena_release_type();
+
+  // .substrait.Expression input = 2;
+  bool has_input() const;
+  private:
+  bool _internal_has_input() const;
+  public:
+  void clear_input();
+  const ::substrait::Expression& input() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_input();
+  ::substrait::Expression* mutable_input();
+  void set_allocated_input(::substrait::Expression* input);
+  private:
+  const ::substrait::Expression& _internal_input() const;
+  ::substrait::Expression* _internal_mutable_input();
+  public:
+  void unsafe_arena_set_allocated_input(
+      ::substrait::Expression* input);
+  ::substrait::Expression* unsafe_arena_release_input();
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.Cast)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Type* type_;
+  ::substrait::Expression* input_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_SwitchExpression_IfValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.SwitchExpression.IfValue) */ {
+ public:
+  inline Expression_SwitchExpression_IfValue() : Expression_SwitchExpression_IfValue(nullptr) {}
+  ~Expression_SwitchExpression_IfValue() override;
+  explicit constexpr Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_SwitchExpression_IfValue(const Expression_SwitchExpression_IfValue& from);
+  Expression_SwitchExpression_IfValue(Expression_SwitchExpression_IfValue&& from) noexcept
+    : Expression_SwitchExpression_IfValue() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_SwitchExpression_IfValue& operator=(const Expression_SwitchExpression_IfValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_SwitchExpression_IfValue& operator=(Expression_SwitchExpression_IfValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_SwitchExpression_IfValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_SwitchExpression_IfValue* internal_default_instance() {
+    return reinterpret_cast<const Expression_SwitchExpression_IfValue*>(
+               &_Expression_SwitchExpression_IfValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    21;
+
+  friend void swap(Expression_SwitchExpression_IfValue& a, Expression_SwitchExpression_IfValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_SwitchExpression_IfValue* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_SwitchExpression_IfValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_SwitchExpression_IfValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_SwitchExpression_IfValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_SwitchExpression_IfValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_SwitchExpression_IfValue& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_SwitchExpression_IfValue* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.SwitchExpression.IfValue";
+  }
+  protected:
+  explicit Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIfFieldNumber = 1,
+    kThenFieldNumber = 2,
+  };
+  // .substrait.Expression.Literal if = 1;
+  bool has_if_() const;
+  private:
+  bool _internal_has_if_() const;
+  public:
+  void clear_if_();
+  const ::substrait::Expression_Literal& if_() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_if_();
+  ::substrait::Expression_Literal* mutable_if_();
+  void set_allocated_if_(::substrait::Expression_Literal* if_);
+  private:
+  const ::substrait::Expression_Literal& _internal_if_() const;
+  ::substrait::Expression_Literal* _internal_mutable_if_();
+  public:
+  void unsafe_arena_set_allocated_if_(
+      ::substrait::Expression_Literal* if_);
+  ::substrait::Expression_Literal* unsafe_arena_release_if_();
+
+  // .substrait.Expression then = 2;
+  bool has_then() const;
+  private:
+  bool _internal_has_then() const;
+  public:
+  void clear_then();
+  const ::substrait::Expression& then() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_then();
+  ::substrait::Expression* mutable_then();
+  void set_allocated_then(::substrait::Expression* then);
+  private:
+  const ::substrait::Expression& _internal_then() const;
+  ::substrait::Expression* _internal_mutable_then();
+  public:
+  void unsafe_arena_set_allocated_then(
+      ::substrait::Expression* then);
+  ::substrait::Expression* unsafe_arena_release_then();
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.SwitchExpression.IfValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Expression_Literal* if__;
+  ::substrait::Expression* then_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_SwitchExpression final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.SwitchExpression) */ {
+ public:
+  inline Expression_SwitchExpression() : Expression_SwitchExpression(nullptr) {}
+  ~Expression_SwitchExpression() override;
+  explicit constexpr Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_SwitchExpression(const Expression_SwitchExpression& from);
+  Expression_SwitchExpression(Expression_SwitchExpression&& from) noexcept
+    : Expression_SwitchExpression() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_SwitchExpression& operator=(const Expression_SwitchExpression& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_SwitchExpression& operator=(Expression_SwitchExpression&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_SwitchExpression& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_SwitchExpression* internal_default_instance() {
+    return reinterpret_cast<const Expression_SwitchExpression*>(
+               &_Expression_SwitchExpression_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    22;
+
+  friend void swap(Expression_SwitchExpression& a, Expression_SwitchExpression& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_SwitchExpression* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_SwitchExpression* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_SwitchExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_SwitchExpression>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_SwitchExpression& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_SwitchExpression& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_SwitchExpression* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.SwitchExpression";
+  }
+  protected:
+  explicit Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_SwitchExpression_IfValue IfValue;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIfsFieldNumber = 1,
+    kElseFieldNumber = 2,
+  };
+  // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1;
+  int ifs_size() const;
+  private:
+  int _internal_ifs_size() const;
+  public:
+  void clear_ifs();
+  ::substrait::Expression_SwitchExpression_IfValue* mutable_ifs(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >*
+      mutable_ifs();
+  private:
+  const ::substrait::Expression_SwitchExpression_IfValue& _internal_ifs(int index) const;
+  ::substrait::Expression_SwitchExpression_IfValue* _internal_add_ifs();
+  public:
+  const ::substrait::Expression_SwitchExpression_IfValue& ifs(int index) const;
+  ::substrait::Expression_SwitchExpression_IfValue* add_ifs();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >&
+      ifs() const;
+
+  // .substrait.Expression else = 2;
+  bool has_else_() const;
+  private:
+  bool _internal_has_else_() const;
+  public:
+  void clear_else_();
+  const ::substrait::Expression& else_() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_else_();
+  ::substrait::Expression* mutable_else_();
+  void set_allocated_else_(::substrait::Expression* else_);
+  private:
+  const ::substrait::Expression& _internal_else_() const;
+  ::substrait::Expression* _internal_mutable_else_();
+  public:
+  void unsafe_arena_set_allocated_else_(
+      ::substrait::Expression* else_);
+  ::substrait::Expression* unsafe_arena_release_else_();
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.SwitchExpression)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue > ifs_;
+  ::substrait::Expression* else__;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_SingularOrList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.SingularOrList) */ {
+ public:
+  inline Expression_SingularOrList() : Expression_SingularOrList(nullptr) {}
+  ~Expression_SingularOrList() override;
+  explicit constexpr Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_SingularOrList(const Expression_SingularOrList& from);
+  Expression_SingularOrList(Expression_SingularOrList&& from) noexcept
+    : Expression_SingularOrList() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_SingularOrList& operator=(const Expression_SingularOrList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_SingularOrList& operator=(Expression_SingularOrList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_SingularOrList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_SingularOrList* internal_default_instance() {
+    return reinterpret_cast<const Expression_SingularOrList*>(
+               &_Expression_SingularOrList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    23;
+
+  friend void swap(Expression_SingularOrList& a, Expression_SingularOrList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_SingularOrList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_SingularOrList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_SingularOrList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_SingularOrList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_SingularOrList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_SingularOrList& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_SingularOrList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.SingularOrList";
+  }
+  protected:
+  explicit Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOptionsFieldNumber = 2,
+    kValueFieldNumber = 1,
+  };
+  // repeated .substrait.Expression options = 2;
+  int options_size() const;
+  private:
+  int _internal_options_size() const;
+  public:
+  void clear_options();
+  ::substrait::Expression* mutable_options(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+      mutable_options();
+  private:
+  const ::substrait::Expression& _internal_options(int index) const;
+  ::substrait::Expression* _internal_add_options();
+  public:
+  const ::substrait::Expression& options(int index) const;
+  ::substrait::Expression* add_options();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+      options() const;
+
+  // .substrait.Expression value = 1;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const ::substrait::Expression& value() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_value();
+  ::substrait::Expression* mutable_value();
+  void set_allocated_value(::substrait::Expression* value);
+  private:
+  const ::substrait::Expression& _internal_value() const;
+  ::substrait::Expression* _internal_mutable_value();
+  public:
+  void unsafe_arena_set_allocated_value(
+      ::substrait::Expression* value);
+  ::substrait::Expression* unsafe_arena_release_value();
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.SingularOrList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > options_;
+  ::substrait::Expression* value_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MultiOrList_Record final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MultiOrList.Record) */ {
+ public:
+  inline Expression_MultiOrList_Record() : Expression_MultiOrList_Record(nullptr) {}
+  ~Expression_MultiOrList_Record() override;
+  explicit constexpr Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MultiOrList_Record(const Expression_MultiOrList_Record& from);
+  Expression_MultiOrList_Record(Expression_MultiOrList_Record&& from) noexcept
+    : Expression_MultiOrList_Record() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MultiOrList_Record& operator=(const Expression_MultiOrList_Record& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MultiOrList_Record& operator=(Expression_MultiOrList_Record&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MultiOrList_Record& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_MultiOrList_Record* internal_default_instance() {
+    return reinterpret_cast<const Expression_MultiOrList_Record*>(
+               &_Expression_MultiOrList_Record_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    24;
+
+  friend void swap(Expression_MultiOrList_Record& a, Expression_MultiOrList_Record& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MultiOrList_Record* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MultiOrList_Record* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MultiOrList_Record* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MultiOrList_Record>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MultiOrList_Record& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MultiOrList_Record& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MultiOrList_Record* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MultiOrList.Record";
+  }
+  protected:
+  explicit Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFieldsFieldNumber = 1,
+  };
+  // repeated .substrait.Expression fields = 1;
+  int fields_size() const;
+  private:
+  int _internal_fields_size() const;
+  public:
+  void clear_fields();
+  ::substrait::Expression* mutable_fields(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+      mutable_fields();
+  private:
+  const ::substrait::Expression& _internal_fields(int index) const;
+  ::substrait::Expression* _internal_add_fields();
+  public:
+  const ::substrait::Expression& fields(int index) const;
+  ::substrait::Expression* add_fields();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+      fields() const;
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MultiOrList.Record)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > fields_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MultiOrList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MultiOrList) */ {
+ public:
+  inline Expression_MultiOrList() : Expression_MultiOrList(nullptr) {}
+  ~Expression_MultiOrList() override;
+  explicit constexpr Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MultiOrList(const Expression_MultiOrList& from);
+  Expression_MultiOrList(Expression_MultiOrList&& from) noexcept
+    : Expression_MultiOrList() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MultiOrList& operator=(const Expression_MultiOrList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MultiOrList& operator=(Expression_MultiOrList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MultiOrList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_MultiOrList* internal_default_instance() {
+    return reinterpret_cast<const Expression_MultiOrList*>(
+               &_Expression_MultiOrList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    25;
+
+  friend void swap(Expression_MultiOrList& a, Expression_MultiOrList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MultiOrList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MultiOrList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MultiOrList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MultiOrList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MultiOrList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MultiOrList& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MultiOrList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MultiOrList";
+  }
+  protected:
+  explicit Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_MultiOrList_Record Record;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+    kOptionsFieldNumber = 2,
+  };
+  // repeated .substrait.Expression value = 1;
+  int value_size() const;
+  private:
+  int _internal_value_size() const;
+  public:
+  void clear_value();
+  ::substrait::Expression* mutable_value(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+      mutable_value();
+  private:
+  const ::substrait::Expression& _internal_value(int index) const;
+  ::substrait::Expression* _internal_add_value();
+  public:
+  const ::substrait::Expression& value(int index) const;
+  ::substrait::Expression* add_value();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+      value() const;
+
+  // repeated .substrait.Expression.MultiOrList.Record options = 2;
+  int options_size() const;
+  private:
+  int _internal_options_size() const;
+  public:
+  void clear_options();
+  ::substrait::Expression_MultiOrList_Record* mutable_options(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >*
+      mutable_options();
+  private:
+  const ::substrait::Expression_MultiOrList_Record& _internal_options(int index) const;
+  ::substrait::Expression_MultiOrList_Record* _internal_add_options();
+  public:
+  const ::substrait::Expression_MultiOrList_Record& options(int index) const;
+  ::substrait::Expression_MultiOrList_Record* add_options();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >&
+      options() const;
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MultiOrList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > value_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record > options_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_EmbeddedFunction_PythonPickleFunction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.EmbeddedFunction.PythonPickleFunction) */ {
+ public:
+  inline Expression_EmbeddedFunction_PythonPickleFunction() : Expression_EmbeddedFunction_PythonPickleFunction(nullptr) {}
+  ~Expression_EmbeddedFunction_PythonPickleFunction() override;
+  explicit constexpr Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_EmbeddedFunction_PythonPickleFunction(const Expression_EmbeddedFunction_PythonPickleFunction& from);
+  Expression_EmbeddedFunction_PythonPickleFunction(Expression_EmbeddedFunction_PythonPickleFunction&& from) noexcept
+    : Expression_EmbeddedFunction_PythonPickleFunction() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_EmbeddedFunction_PythonPickleFunction& operator=(const Expression_EmbeddedFunction_PythonPickleFunction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_EmbeddedFunction_PythonPickleFunction& operator=(Expression_EmbeddedFunction_PythonPickleFunction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_EmbeddedFunction_PythonPickleFunction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_EmbeddedFunction_PythonPickleFunction* internal_default_instance() {
+    return reinterpret_cast<const Expression_EmbeddedFunction_PythonPickleFunction*>(
+               &_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    26;
+
+  friend void swap(Expression_EmbeddedFunction_PythonPickleFunction& a, Expression_EmbeddedFunction_PythonPickleFunction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_EmbeddedFunction_PythonPickleFunction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_EmbeddedFunction_PythonPickleFunction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_EmbeddedFunction_PythonPickleFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_EmbeddedFunction_PythonPickleFunction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_EmbeddedFunction_PythonPickleFunction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.EmbeddedFunction.PythonPickleFunction";
+  }
+  protected:
+  explicit Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPrerequisiteFieldNumber = 2,
+    kFunctionFieldNumber = 1,
+  };
+  // repeated string prerequisite = 2;
+  int prerequisite_size() const;
+  private:
+  int _internal_prerequisite_size() const;
+  public:
+  void clear_prerequisite();
+  const std::string& prerequisite(int index) const;
+  std::string* mutable_prerequisite(int index);
+  void set_prerequisite(int index, const std::string& value);
+  void set_prerequisite(int index, std::string&& value);
+  void set_prerequisite(int index, const char* value);
+  void set_prerequisite(int index, const char* value, size_t size);
+  std::string* add_prerequisite();
+  void add_prerequisite(const std::string& value);
+  void add_prerequisite(std::string&& value);
+  void add_prerequisite(const char* value);
+  void add_prerequisite(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& prerequisite() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_prerequisite();
+  private:
+  const std::string& _internal_prerequisite(int index) const;
+  std::string* _internal_add_prerequisite();
+  public:
+
+  // bytes function = 1;
+  void clear_function();
+  const std::string& function() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_function(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_function();
+  PROTOBUF_NODISCARD std::string* release_function();
+  void set_allocated_function(std::string* function);
+  private:
+  const std::string& _internal_function() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_function(const std::string& value);
+  std::string* _internal_mutable_function();
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.EmbeddedFunction.PythonPickleFunction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> prerequisite_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr function_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_EmbeddedFunction_WebAssemblyFunction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) */ {
+ public:
+  inline Expression_EmbeddedFunction_WebAssemblyFunction() : Expression_EmbeddedFunction_WebAssemblyFunction(nullptr) {}
+  ~Expression_EmbeddedFunction_WebAssemblyFunction() override;
+  explicit constexpr Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_EmbeddedFunction_WebAssemblyFunction(const Expression_EmbeddedFunction_WebAssemblyFunction& from);
+  Expression_EmbeddedFunction_WebAssemblyFunction(Expression_EmbeddedFunction_WebAssemblyFunction&& from) noexcept
+    : Expression_EmbeddedFunction_WebAssemblyFunction() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_EmbeddedFunction_WebAssemblyFunction& operator=(const Expression_EmbeddedFunction_WebAssemblyFunction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_EmbeddedFunction_WebAssemblyFunction& operator=(Expression_EmbeddedFunction_WebAssemblyFunction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_EmbeddedFunction_WebAssemblyFunction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_EmbeddedFunction_WebAssemblyFunction* internal_default_instance() {
+    return reinterpret_cast<const Expression_EmbeddedFunction_WebAssemblyFunction*>(
+               &_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    27;
+
+  friend void swap(Expression_EmbeddedFunction_WebAssemblyFunction& a, Expression_EmbeddedFunction_WebAssemblyFunction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_EmbeddedFunction_WebAssemblyFunction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_EmbeddedFunction_WebAssemblyFunction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_EmbeddedFunction_WebAssemblyFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_EmbeddedFunction_WebAssemblyFunction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_EmbeddedFunction_WebAssemblyFunction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.EmbeddedFunction.WebAssemblyFunction";
+  }
+  protected:
+  explicit Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPrerequisiteFieldNumber = 2,
+    kScriptFieldNumber = 1,
+  };
+  // repeated string prerequisite = 2;
+  int prerequisite_size() const;
+  private:
+  int _internal_prerequisite_size() const;
+  public:
+  void clear_prerequisite();
+  const std::string& prerequisite(int index) const;
+  std::string* mutable_prerequisite(int index);
+  void set_prerequisite(int index, const std::string& value);
+  void set_prerequisite(int index, std::string&& value);
+  void set_prerequisite(int index, const char* value);
+  void set_prerequisite(int index, const char* value, size_t size);
+  std::string* add_prerequisite();
+  void add_prerequisite(const std::string& value);
+  void add_prerequisite(std::string&& value);
+  void add_prerequisite(const char* value);
+  void add_prerequisite(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& prerequisite() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_prerequisite();
+  private:
+  const std::string& _internal_prerequisite(int index) const;
+  std::string* _internal_add_prerequisite();
+  public:
+
+  // bytes script = 1;
+  void clear_script();
+  const std::string& script() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_script(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_script();
+  PROTOBUF_NODISCARD std::string* release_script();
+  void set_allocated_script(std::string* script);
+  private:
+  const std::string& _internal_script() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_script(const std::string& value);
+  std::string* _internal_mutable_script();
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.EmbeddedFunction.WebAssemblyFunction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> prerequisite_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr script_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_EmbeddedFunction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.EmbeddedFunction) */ {
+ public:
+  inline Expression_EmbeddedFunction() : Expression_EmbeddedFunction(nullptr) {}
+  ~Expression_EmbeddedFunction() override;
+  explicit constexpr Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_EmbeddedFunction(const Expression_EmbeddedFunction& from);
+  Expression_EmbeddedFunction(Expression_EmbeddedFunction&& from) noexcept
+    : Expression_EmbeddedFunction() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_EmbeddedFunction& operator=(const Expression_EmbeddedFunction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_EmbeddedFunction& operator=(Expression_EmbeddedFunction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_EmbeddedFunction& default_instance() {
+    return *internal_default_instance();
+  }
+  enum KindCase {
+    kPythonPickleFunction = 3,
+    kWebAssemblyFunction = 4,
+    KIND_NOT_SET = 0,
+  };
+
+  static inline const Expression_EmbeddedFunction* internal_default_instance() {
+    return reinterpret_cast<const Expression_EmbeddedFunction*>(
+               &_Expression_EmbeddedFunction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    28;
+
+  friend void swap(Expression_EmbeddedFunction& a, Expression_EmbeddedFunction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_EmbeddedFunction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_EmbeddedFunction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_EmbeddedFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_EmbeddedFunction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_EmbeddedFunction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_EmbeddedFunction& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_EmbeddedFunction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.EmbeddedFunction";
+  }
+  protected:
+  explicit Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_EmbeddedFunction_PythonPickleFunction PythonPickleFunction;
+  typedef Expression_EmbeddedFunction_WebAssemblyFunction WebAssemblyFunction;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kArgumentsFieldNumber = 1,
+    kOutputTypeFieldNumber = 2,
+    kPythonPickleFunctionFieldNumber = 3,
+    kWebAssemblyFunctionFieldNumber = 4,
+  };
+  // repeated .substrait.Expression arguments = 1;
+  int arguments_size() const;
+  private:
+  int _internal_arguments_size() const;
+  public:
+  void clear_arguments();
+  ::substrait::Expression* mutable_arguments(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+      mutable_arguments();
+  private:
+  const ::substrait::Expression& _internal_arguments(int index) const;
+  ::substrait::Expression* _internal_add_arguments();
+  public:
+  const ::substrait::Expression& arguments(int index) const;
+  ::substrait::Expression* add_arguments();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+      arguments() const;
+
+  // .substrait.Type output_type = 2;
+  bool has_output_type() const;
+  private:
+  bool _internal_has_output_type() const;
+  public:
+  void clear_output_type();
+  const ::substrait::Type& output_type() const;
+  PROTOBUF_NODISCARD ::substrait::Type* release_output_type();
+  ::substrait::Type* mutable_output_type();
+  void set_allocated_output_type(::substrait::Type* output_type);
+  private:
+  const ::substrait::Type& _internal_output_type() const;
+  ::substrait::Type* _internal_mutable_output_type();
+  public:
+  void unsafe_arena_set_allocated_output_type(
+      ::substrait::Type* output_type);
+  ::substrait::Type* unsafe_arena_release_output_type();
+
+  // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3;
+  bool has_python_pickle_function() const;
+  private:
+  bool _internal_has_python_pickle_function() const;
+  public:
+  void clear_python_pickle_function();
+  const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& python_pickle_function() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* release_python_pickle_function();
+  ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* mutable_python_pickle_function();
+  void set_allocated_python_pickle_function(::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function);
+  private:
+  const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& _internal_python_pickle_function() const;
+  ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* _internal_mutable_python_pickle_function();
+  public:
+  void unsafe_arena_set_allocated_python_pickle_function(
+      ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function);
+  ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* unsafe_arena_release_python_pickle_function();
+
+  // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4;
+  bool has_web_assembly_function() const;
+  private:
+  bool _internal_has_web_assembly_function() const;
+  public:
+  void clear_web_assembly_function();
+  const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& web_assembly_function() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* release_web_assembly_function();
+  ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* mutable_web_assembly_function();
+  void set_allocated_web_assembly_function(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function);
+  private:
+  const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& _internal_web_assembly_function() const;
+  ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* _internal_mutable_web_assembly_function();
+  public:
+  void unsafe_arena_set_allocated_web_assembly_function(
+      ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function);
+  ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* unsafe_arena_release_web_assembly_function();
+
+  void clear_kind();
+  KindCase kind_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.Expression.EmbeddedFunction)
+ private:
+  class _Internal;
+  void set_has_python_pickle_function();
+  void set_has_web_assembly_function();
+
+  inline bool has_kind() const;
+  inline void clear_has_kind();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > arguments_;
+  ::substrait::Type* output_type_;
+  union KindUnion {
+    constexpr KindUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function_;
+    ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function_;
+  } kind_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_ReferenceSegment_MapKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment.MapKey) */ {
+ public:
+  inline Expression_ReferenceSegment_MapKey() : Expression_ReferenceSegment_MapKey(nullptr) {}
+  ~Expression_ReferenceSegment_MapKey() override;
+  explicit constexpr Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_ReferenceSegment_MapKey(const Expression_ReferenceSegment_MapKey& from);
+  Expression_ReferenceSegment_MapKey(Expression_ReferenceSegment_MapKey&& from) noexcept
+    : Expression_ReferenceSegment_MapKey() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_ReferenceSegment_MapKey& operator=(const Expression_ReferenceSegment_MapKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_ReferenceSegment_MapKey& operator=(Expression_ReferenceSegment_MapKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_ReferenceSegment_MapKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_ReferenceSegment_MapKey* internal_default_instance() {
+    return reinterpret_cast<const Expression_ReferenceSegment_MapKey*>(
+               &_Expression_ReferenceSegment_MapKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    29;
+
+  friend void swap(Expression_ReferenceSegment_MapKey& a, Expression_ReferenceSegment_MapKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_ReferenceSegment_MapKey* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_ReferenceSegment_MapKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_ReferenceSegment_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_ReferenceSegment_MapKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_ReferenceSegment_MapKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_ReferenceSegment_MapKey& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_ReferenceSegment_MapKey* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.ReferenceSegment.MapKey";
+  }
+  protected:
+  explicit Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMapKeyFieldNumber = 1,
+    kChildFieldNumber = 2,
+  };
+  // .substrait.Expression.Literal map_key = 1;
+  bool has_map_key() const;
+  private:
+  bool _internal_has_map_key() const;
+  public:
+  void clear_map_key();
+  const ::substrait::Expression_Literal& map_key() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_map_key();
+  ::substrait::Expression_Literal* mutable_map_key();
+  void set_allocated_map_key(::substrait::Expression_Literal* map_key);
+  private:
+  const ::substrait::Expression_Literal& _internal_map_key() const;
+  ::substrait::Expression_Literal* _internal_mutable_map_key();
+  public:
+  void unsafe_arena_set_allocated_map_key(
+      ::substrait::Expression_Literal* map_key);
+  ::substrait::Expression_Literal* unsafe_arena_release_map_key();
+
+  // .substrait.Expression.ReferenceSegment child = 2;
+  bool has_child() const;
+  private:
+  bool _internal_has_child() const;
+  public:
+  void clear_child();
+  const ::substrait::Expression_ReferenceSegment& child() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment* release_child();
+  ::substrait::Expression_ReferenceSegment* mutable_child();
+  void set_allocated_child(::substrait::Expression_ReferenceSegment* child);
+  private:
+  const ::substrait::Expression_ReferenceSegment& _internal_child() const;
+  ::substrait::Expression_ReferenceSegment* _internal_mutable_child();
+  public:
+  void unsafe_arena_set_allocated_child(
+      ::substrait::Expression_ReferenceSegment* child);
+  ::substrait::Expression_ReferenceSegment* unsafe_arena_release_child();
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment.MapKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Expression_Literal* map_key_;
+  ::substrait::Expression_ReferenceSegment* child_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_ReferenceSegment_StructField final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment.StructField) */ {
+ public:
+  inline Expression_ReferenceSegment_StructField() : Expression_ReferenceSegment_StructField(nullptr) {}
+  ~Expression_ReferenceSegment_StructField() override;
+  explicit constexpr Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_ReferenceSegment_StructField(const Expression_ReferenceSegment_StructField& from);
+  Expression_ReferenceSegment_StructField(Expression_ReferenceSegment_StructField&& from) noexcept
+    : Expression_ReferenceSegment_StructField() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_ReferenceSegment_StructField& operator=(const Expression_ReferenceSegment_StructField& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_ReferenceSegment_StructField& operator=(Expression_ReferenceSegment_StructField&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_ReferenceSegment_StructField& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_ReferenceSegment_StructField* internal_default_instance() {
+    return reinterpret_cast<const Expression_ReferenceSegment_StructField*>(
+               &_Expression_ReferenceSegment_StructField_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    30;
+
+  friend void swap(Expression_ReferenceSegment_StructField& a, Expression_ReferenceSegment_StructField& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_ReferenceSegment_StructField* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_ReferenceSegment_StructField* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_ReferenceSegment_StructField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_ReferenceSegment_StructField>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_ReferenceSegment_StructField& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_ReferenceSegment_StructField& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_ReferenceSegment_StructField* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.ReferenceSegment.StructField";
+  }
+  protected:
+  explicit Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kChildFieldNumber = 2,
+    kFieldFieldNumber = 1,
+  };
+  // .substrait.Expression.ReferenceSegment child = 2;
+  bool has_child() const;
+  private:
+  bool _internal_has_child() const;
+  public:
+  void clear_child();
+  const ::substrait::Expression_ReferenceSegment& child() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment* release_child();
+  ::substrait::Expression_ReferenceSegment* mutable_child();
+  void set_allocated_child(::substrait::Expression_ReferenceSegment* child);
+  private:
+  const ::substrait::Expression_ReferenceSegment& _internal_child() const;
+  ::substrait::Expression_ReferenceSegment* _internal_mutable_child();
+  public:
+  void unsafe_arena_set_allocated_child(
+      ::substrait::Expression_ReferenceSegment* child);
+  ::substrait::Expression_ReferenceSegment* unsafe_arena_release_child();
+
+  // int32 field = 1;
+  void clear_field();
+  int32_t field() const;
+  void set_field(int32_t value);
+  private:
+  int32_t _internal_field() const;
+  void _internal_set_field(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment.StructField)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Expression_ReferenceSegment* child_;
+  int32_t field_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_ReferenceSegment_ListElement final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment.ListElement) */ {
+ public:
+  inline Expression_ReferenceSegment_ListElement() : Expression_ReferenceSegment_ListElement(nullptr) {}
+  ~Expression_ReferenceSegment_ListElement() override;
+  explicit constexpr Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_ReferenceSegment_ListElement(const Expression_ReferenceSegment_ListElement& from);
+  Expression_ReferenceSegment_ListElement(Expression_ReferenceSegment_ListElement&& from) noexcept
+    : Expression_ReferenceSegment_ListElement() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_ReferenceSegment_ListElement& operator=(const Expression_ReferenceSegment_ListElement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_ReferenceSegment_ListElement& operator=(Expression_ReferenceSegment_ListElement&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_ReferenceSegment_ListElement& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_ReferenceSegment_ListElement* internal_default_instance() {
+    return reinterpret_cast<const Expression_ReferenceSegment_ListElement*>(
+               &_Expression_ReferenceSegment_ListElement_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    31;
+
+  friend void swap(Expression_ReferenceSegment_ListElement& a, Expression_ReferenceSegment_ListElement& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_ReferenceSegment_ListElement* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_ReferenceSegment_ListElement* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_ReferenceSegment_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_ReferenceSegment_ListElement>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_ReferenceSegment_ListElement& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_ReferenceSegment_ListElement& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_ReferenceSegment_ListElement* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.ReferenceSegment.ListElement";
+  }
+  protected:
+  explicit Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kChildFieldNumber = 2,
+    kOffsetFieldNumber = 1,
+  };
+  // .substrait.Expression.ReferenceSegment child = 2;
+  bool has_child() const;
+  private:
+  bool _internal_has_child() const;
+  public:
+  void clear_child();
+  const ::substrait::Expression_ReferenceSegment& child() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment* release_child();
+  ::substrait::Expression_ReferenceSegment* mutable_child();
+  void set_allocated_child(::substrait::Expression_ReferenceSegment* child);
+  private:
+  const ::substrait::Expression_ReferenceSegment& _internal_child() const;
+  ::substrait::Expression_ReferenceSegment* _internal_mutable_child();
+  public:
+  void unsafe_arena_set_allocated_child(
+      ::substrait::Expression_ReferenceSegment* child);
+  ::substrait::Expression_ReferenceSegment* unsafe_arena_release_child();
+
+  // int32 offset = 1;
+  void clear_offset();
+  int32_t offset() const;
+  void set_offset(int32_t value);
+  private:
+  int32_t _internal_offset() const;
+  void _internal_set_offset(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment.ListElement)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Expression_ReferenceSegment* child_;
+  int32_t offset_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_ReferenceSegment final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment) */ {
+ public:
+  inline Expression_ReferenceSegment() : Expression_ReferenceSegment(nullptr) {}
+  ~Expression_ReferenceSegment() override;
+  explicit constexpr Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_ReferenceSegment(const Expression_ReferenceSegment& from);
+  Expression_ReferenceSegment(Expression_ReferenceSegment&& from) noexcept
+    : Expression_ReferenceSegment() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_ReferenceSegment& operator=(const Expression_ReferenceSegment& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_ReferenceSegment& operator=(Expression_ReferenceSegment&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_ReferenceSegment& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ReferenceTypeCase {
+    kMapKey = 1,
+    kStructField = 2,
+    kListElement = 3,
+    REFERENCE_TYPE_NOT_SET = 0,
+  };
+
+  static inline const Expression_ReferenceSegment* internal_default_instance() {
+    return reinterpret_cast<const Expression_ReferenceSegment*>(
+               &_Expression_ReferenceSegment_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    32;
+
+  friend void swap(Expression_ReferenceSegment& a, Expression_ReferenceSegment& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_ReferenceSegment* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_ReferenceSegment* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_ReferenceSegment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_ReferenceSegment>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_ReferenceSegment& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_ReferenceSegment& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_ReferenceSegment* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.ReferenceSegment";
+  }
+  protected:
+  explicit Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_ReferenceSegment_MapKey MapKey;
+  typedef Expression_ReferenceSegment_StructField StructField;
+  typedef Expression_ReferenceSegment_ListElement ListElement;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMapKeyFieldNumber = 1,
+    kStructFieldFieldNumber = 2,
+    kListElementFieldNumber = 3,
+  };
+  // .substrait.Expression.ReferenceSegment.MapKey map_key = 1;
+  bool has_map_key() const;
+  private:
+  bool _internal_has_map_key() const;
+  public:
+  void clear_map_key();
+  const ::substrait::Expression_ReferenceSegment_MapKey& map_key() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment_MapKey* release_map_key();
+  ::substrait::Expression_ReferenceSegment_MapKey* mutable_map_key();
+  void set_allocated_map_key(::substrait::Expression_ReferenceSegment_MapKey* map_key);
+  private:
+  const ::substrait::Expression_ReferenceSegment_MapKey& _internal_map_key() const;
+  ::substrait::Expression_ReferenceSegment_MapKey* _internal_mutable_map_key();
+  public:
+  void unsafe_arena_set_allocated_map_key(
+      ::substrait::Expression_ReferenceSegment_MapKey* map_key);
+  ::substrait::Expression_ReferenceSegment_MapKey* unsafe_arena_release_map_key();
+
+  // .substrait.Expression.ReferenceSegment.StructField struct_field = 2;
+  bool has_struct_field() const;
+  private:
+  bool _internal_has_struct_field() const;
+  public:
+  void clear_struct_field();
+  const ::substrait::Expression_ReferenceSegment_StructField& struct_field() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment_StructField* release_struct_field();
+  ::substrait::Expression_ReferenceSegment_StructField* mutable_struct_field();
+  void set_allocated_struct_field(::substrait::Expression_ReferenceSegment_StructField* struct_field);
+  private:
+  const ::substrait::Expression_ReferenceSegment_StructField& _internal_struct_field() const;
+  ::substrait::Expression_ReferenceSegment_StructField* _internal_mutable_struct_field();
+  public:
+  void unsafe_arena_set_allocated_struct_field(
+      ::substrait::Expression_ReferenceSegment_StructField* struct_field);
+  ::substrait::Expression_ReferenceSegment_StructField* unsafe_arena_release_struct_field();
+
+  // .substrait.Expression.ReferenceSegment.ListElement list_element = 3;
+  bool has_list_element() const;
+  private:
+  bool _internal_has_list_element() const;
+  public:
+  void clear_list_element();
+  const ::substrait::Expression_ReferenceSegment_ListElement& list_element() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment_ListElement* release_list_element();
+  ::substrait::Expression_ReferenceSegment_ListElement* mutable_list_element();
+  void set_allocated_list_element(::substrait::Expression_ReferenceSegment_ListElement* list_element);
+  private:
+  const ::substrait::Expression_ReferenceSegment_ListElement& _internal_list_element() const;
+  ::substrait::Expression_ReferenceSegment_ListElement* _internal_mutable_list_element();
+  public:
+  void unsafe_arena_set_allocated_list_element(
+      ::substrait::Expression_ReferenceSegment_ListElement* list_element);
+  ::substrait::Expression_ReferenceSegment_ListElement* unsafe_arena_release_list_element();
+
+  void clear_reference_type();
+  ReferenceTypeCase reference_type_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment)
+ private:
+  class _Internal;
+  void set_has_map_key();
+  void set_has_struct_field();
+  void set_has_list_element();
+
+  inline bool has_reference_type() const;
+  inline void clear_has_reference_type();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union ReferenceTypeUnion {
+    constexpr ReferenceTypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Expression_ReferenceSegment_MapKey* map_key_;
+    ::substrait::Expression_ReferenceSegment_StructField* struct_field_;
+    ::substrait::Expression_ReferenceSegment_ListElement* list_element_;
+  } reference_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MaskExpression_Select final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.Select) */ {
+ public:
+  inline Expression_MaskExpression_Select() : Expression_MaskExpression_Select(nullptr) {}
+  ~Expression_MaskExpression_Select() override;
+  explicit constexpr Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MaskExpression_Select(const Expression_MaskExpression_Select& from);
+  Expression_MaskExpression_Select(Expression_MaskExpression_Select&& from) noexcept
+    : Expression_MaskExpression_Select() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MaskExpression_Select& operator=(const Expression_MaskExpression_Select& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MaskExpression_Select& operator=(Expression_MaskExpression_Select&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MaskExpression_Select& default_instance() {
+    return *internal_default_instance();
+  }
+  enum TypeCase {
+    kStruct = 1,
+    kList = 2,
+    kMap = 3,
+    TYPE_NOT_SET = 0,
+  };
+
+  static inline const Expression_MaskExpression_Select* internal_default_instance() {
+    return reinterpret_cast<const Expression_MaskExpression_Select*>(
+               &_Expression_MaskExpression_Select_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    33;
+
+  friend void swap(Expression_MaskExpression_Select& a, Expression_MaskExpression_Select& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MaskExpression_Select* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MaskExpression_Select* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MaskExpression_Select* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MaskExpression_Select>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MaskExpression_Select& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MaskExpression_Select& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MaskExpression_Select* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MaskExpression.Select";
+  }
+  protected:
+  explicit Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStructFieldNumber = 1,
+    kListFieldNumber = 2,
+    kMapFieldNumber = 3,
+  };
+  // .substrait.Expression.MaskExpression.StructSelect struct = 1;
+  bool has_struct_() const;
+  private:
+  bool _internal_has_struct_() const;
+  public:
+  void clear_struct_();
+  const ::substrait::Expression_MaskExpression_StructSelect& struct_() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_StructSelect* release_struct_();
+  ::substrait::Expression_MaskExpression_StructSelect* mutable_struct_();
+  void set_allocated_struct_(::substrait::Expression_MaskExpression_StructSelect* struct_);
+  private:
+  const ::substrait::Expression_MaskExpression_StructSelect& _internal_struct_() const;
+  ::substrait::Expression_MaskExpression_StructSelect* _internal_mutable_struct_();
+  public:
+  void unsafe_arena_set_allocated_struct_(
+      ::substrait::Expression_MaskExpression_StructSelect* struct_);
+  ::substrait::Expression_MaskExpression_StructSelect* unsafe_arena_release_struct_();
+
+  // .substrait.Expression.MaskExpression.ListSelect list = 2;
+  bool has_list() const;
+  private:
+  bool _internal_has_list() const;
+  public:
+  void clear_list();
+  const ::substrait::Expression_MaskExpression_ListSelect& list() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_ListSelect* release_list();
+  ::substrait::Expression_MaskExpression_ListSelect* mutable_list();
+  void set_allocated_list(::substrait::Expression_MaskExpression_ListSelect* list);
+  private:
+  const ::substrait::Expression_MaskExpression_ListSelect& _internal_list() const;
+  ::substrait::Expression_MaskExpression_ListSelect* _internal_mutable_list();
+  public:
+  void unsafe_arena_set_allocated_list(
+      ::substrait::Expression_MaskExpression_ListSelect* list);
+  ::substrait::Expression_MaskExpression_ListSelect* unsafe_arena_release_list();
+
+  // .substrait.Expression.MaskExpression.MapSelect map = 3;
+  bool has_map() const;
+  private:
+  bool _internal_has_map() const;
+  public:
+  void clear_map();
+  const ::substrait::Expression_MaskExpression_MapSelect& map() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_MapSelect* release_map();
+  ::substrait::Expression_MaskExpression_MapSelect* mutable_map();
+  void set_allocated_map(::substrait::Expression_MaskExpression_MapSelect* map);
+  private:
+  const ::substrait::Expression_MaskExpression_MapSelect& _internal_map() const;
+  ::substrait::Expression_MaskExpression_MapSelect* _internal_mutable_map();
+  public:
+  void unsafe_arena_set_allocated_map(
+      ::substrait::Expression_MaskExpression_MapSelect* map);
+  ::substrait::Expression_MaskExpression_MapSelect* unsafe_arena_release_map();
+
+  void clear_type();
+  TypeCase type_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.Select)
+ private:
+  class _Internal;
+  void set_has_struct_();
+  void set_has_list();
+  void set_has_map();
+
+  inline bool has_type() const;
+  inline void clear_has_type();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union TypeUnion {
+    constexpr TypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Expression_MaskExpression_StructSelect* struct__;
+    ::substrait::Expression_MaskExpression_ListSelect* list_;
+    ::substrait::Expression_MaskExpression_MapSelect* map_;
+  } type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MaskExpression_StructSelect final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.StructSelect) */ {
+ public:
+  inline Expression_MaskExpression_StructSelect() : Expression_MaskExpression_StructSelect(nullptr) {}
+  ~Expression_MaskExpression_StructSelect() override;
+  explicit constexpr Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MaskExpression_StructSelect(const Expression_MaskExpression_StructSelect& from);
+  Expression_MaskExpression_StructSelect(Expression_MaskExpression_StructSelect&& from) noexcept
+    : Expression_MaskExpression_StructSelect() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MaskExpression_StructSelect& operator=(const Expression_MaskExpression_StructSelect& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MaskExpression_StructSelect& operator=(Expression_MaskExpression_StructSelect&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MaskExpression_StructSelect& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_MaskExpression_StructSelect* internal_default_instance() {
+    return reinterpret_cast<const Expression_MaskExpression_StructSelect*>(
+               &_Expression_MaskExpression_StructSelect_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    34;
+
+  friend void swap(Expression_MaskExpression_StructSelect& a, Expression_MaskExpression_StructSelect& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MaskExpression_StructSelect* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MaskExpression_StructSelect* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MaskExpression_StructSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MaskExpression_StructSelect>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MaskExpression_StructSelect& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MaskExpression_StructSelect& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MaskExpression_StructSelect* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MaskExpression.StructSelect";
+  }
+  protected:
+  explicit Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStructItemsFieldNumber = 1,
+  };
+  // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1;
+  int struct_items_size() const;
+  private:
+  int _internal_struct_items_size() const;
+  public:
+  void clear_struct_items();
+  ::substrait::Expression_MaskExpression_StructItem* mutable_struct_items(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >*
+      mutable_struct_items();
+  private:
+  const ::substrait::Expression_MaskExpression_StructItem& _internal_struct_items(int index) const;
+  ::substrait::Expression_MaskExpression_StructItem* _internal_add_struct_items();
+  public:
+  const ::substrait::Expression_MaskExpression_StructItem& struct_items(int index) const;
+  ::substrait::Expression_MaskExpression_StructItem* add_struct_items();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >&
+      struct_items() const;
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.StructSelect)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem > struct_items_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MaskExpression_StructItem final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.StructItem) */ {
+ public:
+  inline Expression_MaskExpression_StructItem() : Expression_MaskExpression_StructItem(nullptr) {}
+  ~Expression_MaskExpression_StructItem() override;
+  explicit constexpr Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MaskExpression_StructItem(const Expression_MaskExpression_StructItem& from);
+  Expression_MaskExpression_StructItem(Expression_MaskExpression_StructItem&& from) noexcept
+    : Expression_MaskExpression_StructItem() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MaskExpression_StructItem& operator=(const Expression_MaskExpression_StructItem& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MaskExpression_StructItem& operator=(Expression_MaskExpression_StructItem&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MaskExpression_StructItem& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_MaskExpression_StructItem* internal_default_instance() {
+    return reinterpret_cast<const Expression_MaskExpression_StructItem*>(
+               &_Expression_MaskExpression_StructItem_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    35;
+
+  friend void swap(Expression_MaskExpression_StructItem& a, Expression_MaskExpression_StructItem& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MaskExpression_StructItem* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MaskExpression_StructItem* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MaskExpression_StructItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MaskExpression_StructItem>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MaskExpression_StructItem& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MaskExpression_StructItem& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MaskExpression_StructItem* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MaskExpression.StructItem";
+  }
+  protected:
+  explicit Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kChildFieldNumber = 2,
+    kFieldFieldNumber = 1,
+  };
+  // .substrait.Expression.MaskExpression.Select child = 2;
+  bool has_child() const;
+  private:
+  bool _internal_has_child() const;
+  public:
+  void clear_child();
+  const ::substrait::Expression_MaskExpression_Select& child() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_Select* release_child();
+  ::substrait::Expression_MaskExpression_Select* mutable_child();
+  void set_allocated_child(::substrait::Expression_MaskExpression_Select* child);
+  private:
+  const ::substrait::Expression_MaskExpression_Select& _internal_child() const;
+  ::substrait::Expression_MaskExpression_Select* _internal_mutable_child();
+  public:
+  void unsafe_arena_set_allocated_child(
+      ::substrait::Expression_MaskExpression_Select* child);
+  ::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child();
+
+  // int32 field = 1;
+  void clear_field();
+  int32_t field() const;
+  void set_field(int32_t value);
+  private:
+  int32_t _internal_field() const;
+  void _internal_set_field(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.StructItem)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Expression_MaskExpression_Select* child_;
+  int32_t field_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) */ {
+ public:
+  inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() : Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(nullptr) {}
+  ~Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() override;
+  explicit constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from);
+  Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&& from) noexcept
+    : Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& operator=(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& operator=(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* internal_default_instance() {
+    return reinterpret_cast<const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement*>(
+               &_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    36;
+
+  friend void swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& a, Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MaskExpression_ListSelect_ListSelectItem_ListElement>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement";
+  }
+  protected:
+  explicit Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFieldFieldNumber = 1,
+  };
+  // int32 field = 1;
+  void clear_field();
+  int32_t field() const;
+  void set_field(int32_t value);
+  private:
+  int32_t _internal_field() const;
+  void _internal_set_field(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int32_t field_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) */ {
+ public:
+  inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() : Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(nullptr) {}
+  ~Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() override;
+  explicit constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from);
+  Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&& from) noexcept
+    : Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& operator=(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& operator=(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* internal_default_instance() {
+    return reinterpret_cast<const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice*>(
+               &_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    37;
+
+  friend void swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& a, Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice";
+  }
+  protected:
+  explicit Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStartFieldNumber = 1,
+    kEndFieldNumber = 2,
+  };
+  // int32 start = 1;
+  void clear_start();
+  int32_t start() const;
+  void set_start(int32_t value);
+  private:
+  int32_t _internal_start() const;
+  void _internal_set_start(int32_t value);
+  public:
+
+  // int32 end = 2;
+  void clear_end();
+  int32_t end() const;
+  void set_end(int32_t value);
+  private:
+  int32_t _internal_end() const;
+  void _internal_set_end(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int32_t start_;
+  int32_t end_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MaskExpression_ListSelect_ListSelectItem final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) */ {
+ public:
+  inline Expression_MaskExpression_ListSelect_ListSelectItem() : Expression_MaskExpression_ListSelect_ListSelectItem(nullptr) {}
+  ~Expression_MaskExpression_ListSelect_ListSelectItem() override;
+  explicit constexpr Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MaskExpression_ListSelect_ListSelectItem(const Expression_MaskExpression_ListSelect_ListSelectItem& from);
+  Expression_MaskExpression_ListSelect_ListSelectItem(Expression_MaskExpression_ListSelect_ListSelectItem&& from) noexcept
+    : Expression_MaskExpression_ListSelect_ListSelectItem() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MaskExpression_ListSelect_ListSelectItem& operator=(const Expression_MaskExpression_ListSelect_ListSelectItem& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MaskExpression_ListSelect_ListSelectItem& operator=(Expression_MaskExpression_ListSelect_ListSelectItem&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MaskExpression_ListSelect_ListSelectItem& default_instance() {
+    return *internal_default_instance();
+  }
+  enum TypeCase {
+    kItem = 1,
+    kSlice = 2,
+    TYPE_NOT_SET = 0,
+  };
+
+  static inline const Expression_MaskExpression_ListSelect_ListSelectItem* internal_default_instance() {
+    return reinterpret_cast<const Expression_MaskExpression_ListSelect_ListSelectItem*>(
+               &_Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    38;
+
+  friend void swap(Expression_MaskExpression_ListSelect_ListSelectItem& a, Expression_MaskExpression_ListSelect_ListSelectItem& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MaskExpression_ListSelect_ListSelectItem* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MaskExpression_ListSelect_ListSelectItem* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MaskExpression_ListSelect_ListSelectItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MaskExpression_ListSelect_ListSelectItem>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MaskExpression.ListSelect.ListSelectItem";
+  }
+  protected:
+  explicit Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_MaskExpression_ListSelect_ListSelectItem_ListElement ListElement;
+  typedef Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice ListSlice;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kItemFieldNumber = 1,
+    kSliceFieldNumber = 2,
+  };
+  // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1;
+  bool has_item() const;
+  private:
+  bool _internal_has_item() const;
+  public:
+  void clear_item();
+  const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& item() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* release_item();
+  ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* mutable_item();
+  void set_allocated_item(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item);
+  private:
+  const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& _internal_item() const;
+  ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* _internal_mutable_item();
+  public:
+  void unsafe_arena_set_allocated_item(
+      ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item);
+  ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* unsafe_arena_release_item();
+
+  // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2;
+  bool has_slice() const;
+  private:
+  bool _internal_has_slice() const;
+  public:
+  void clear_slice();
+  const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& slice() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* release_slice();
+  ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* mutable_slice();
+  void set_allocated_slice(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice);
+  private:
+  const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& _internal_slice() const;
+  ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* _internal_mutable_slice();
+  public:
+  void unsafe_arena_set_allocated_slice(
+      ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice);
+  ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* unsafe_arena_release_slice();
+
+  void clear_type();
+  TypeCase type_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect.ListSelectItem)
+ private:
+  class _Internal;
+  void set_has_item();
+  void set_has_slice();
+
+  inline bool has_type() const;
+  inline void clear_has_type();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union TypeUnion {
+    constexpr TypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item_;
+    ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice_;
+  } type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MaskExpression_ListSelect final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect) */ {
+ public:
+  inline Expression_MaskExpression_ListSelect() : Expression_MaskExpression_ListSelect(nullptr) {}
+  ~Expression_MaskExpression_ListSelect() override;
+  explicit constexpr Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MaskExpression_ListSelect(const Expression_MaskExpression_ListSelect& from);
+  Expression_MaskExpression_ListSelect(Expression_MaskExpression_ListSelect&& from) noexcept
+    : Expression_MaskExpression_ListSelect() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MaskExpression_ListSelect& operator=(const Expression_MaskExpression_ListSelect& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MaskExpression_ListSelect& operator=(Expression_MaskExpression_ListSelect&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MaskExpression_ListSelect& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_MaskExpression_ListSelect* internal_default_instance() {
+    return reinterpret_cast<const Expression_MaskExpression_ListSelect*>(
+               &_Expression_MaskExpression_ListSelect_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    39;
+
+  friend void swap(Expression_MaskExpression_ListSelect& a, Expression_MaskExpression_ListSelect& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MaskExpression_ListSelect* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MaskExpression_ListSelect* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MaskExpression_ListSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MaskExpression_ListSelect>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MaskExpression_ListSelect& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MaskExpression_ListSelect& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MaskExpression_ListSelect* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MaskExpression.ListSelect";
+  }
+  protected:
+  explicit Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_MaskExpression_ListSelect_ListSelectItem ListSelectItem;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSelectionFieldNumber = 1,
+    kChildFieldNumber = 2,
+  };
+  // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1;
+  int selection_size() const;
+  private:
+  int _internal_selection_size() const;
+  public:
+  void clear_selection();
+  ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* mutable_selection(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >*
+      mutable_selection();
+  private:
+  const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& _internal_selection(int index) const;
+  ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* _internal_add_selection();
+  public:
+  const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& selection(int index) const;
+  ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* add_selection();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >&
+      selection() const;
+
+  // .substrait.Expression.MaskExpression.Select child = 2;
+  bool has_child() const;
+  private:
+  bool _internal_has_child() const;
+  public:
+  void clear_child();
+  const ::substrait::Expression_MaskExpression_Select& child() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_Select* release_child();
+  ::substrait::Expression_MaskExpression_Select* mutable_child();
+  void set_allocated_child(::substrait::Expression_MaskExpression_Select* child);
+  private:
+  const ::substrait::Expression_MaskExpression_Select& _internal_child() const;
+  ::substrait::Expression_MaskExpression_Select* _internal_mutable_child();
+  public:
+  void unsafe_arena_set_allocated_child(
+      ::substrait::Expression_MaskExpression_Select* child);
+  ::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child();
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem > selection_;
+  ::substrait::Expression_MaskExpression_Select* child_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MaskExpression_MapSelect_MapKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.MapSelect.MapKey) */ {
+ public:
+  inline Expression_MaskExpression_MapSelect_MapKey() : Expression_MaskExpression_MapSelect_MapKey(nullptr) {}
+  ~Expression_MaskExpression_MapSelect_MapKey() override;
+  explicit constexpr Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MaskExpression_MapSelect_MapKey(const Expression_MaskExpression_MapSelect_MapKey& from);
+  Expression_MaskExpression_MapSelect_MapKey(Expression_MaskExpression_MapSelect_MapKey&& from) noexcept
+    : Expression_MaskExpression_MapSelect_MapKey() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MaskExpression_MapSelect_MapKey& operator=(const Expression_MaskExpression_MapSelect_MapKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MaskExpression_MapSelect_MapKey& operator=(Expression_MaskExpression_MapSelect_MapKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MaskExpression_MapSelect_MapKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_MaskExpression_MapSelect_MapKey* internal_default_instance() {
+    return reinterpret_cast<const Expression_MaskExpression_MapSelect_MapKey*>(
+               &_Expression_MaskExpression_MapSelect_MapKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    40;
+
+  friend void swap(Expression_MaskExpression_MapSelect_MapKey& a, Expression_MaskExpression_MapSelect_MapKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MaskExpression_MapSelect_MapKey* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MaskExpression_MapSelect_MapKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MaskExpression_MapSelect_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MaskExpression_MapSelect_MapKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MaskExpression_MapSelect_MapKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MaskExpression_MapSelect_MapKey& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MaskExpression_MapSelect_MapKey* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MaskExpression.MapSelect.MapKey";
+  }
+  protected:
+  explicit Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMapKeyFieldNumber = 1,
+  };
+  // string map_key = 1;
+  void clear_map_key();
+  const std::string& map_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_map_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_map_key();
+  PROTOBUF_NODISCARD std::string* release_map_key();
+  void set_allocated_map_key(std::string* map_key);
+  private:
+  const std::string& _internal_map_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_map_key(const std::string& value);
+  std::string* _internal_mutable_map_key();
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.MapSelect.MapKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MaskExpression_MapSelect_MapKeyExpression final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) */ {
+ public:
+  inline Expression_MaskExpression_MapSelect_MapKeyExpression() : Expression_MaskExpression_MapSelect_MapKeyExpression(nullptr) {}
+  ~Expression_MaskExpression_MapSelect_MapKeyExpression() override;
+  explicit constexpr Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MaskExpression_MapSelect_MapKeyExpression(const Expression_MaskExpression_MapSelect_MapKeyExpression& from);
+  Expression_MaskExpression_MapSelect_MapKeyExpression(Expression_MaskExpression_MapSelect_MapKeyExpression&& from) noexcept
+    : Expression_MaskExpression_MapSelect_MapKeyExpression() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MaskExpression_MapSelect_MapKeyExpression& operator=(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MaskExpression_MapSelect_MapKeyExpression& operator=(Expression_MaskExpression_MapSelect_MapKeyExpression&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MaskExpression_MapSelect_MapKeyExpression& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_MaskExpression_MapSelect_MapKeyExpression* internal_default_instance() {
+    return reinterpret_cast<const Expression_MaskExpression_MapSelect_MapKeyExpression*>(
+               &_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    41;
+
+  friend void swap(Expression_MaskExpression_MapSelect_MapKeyExpression& a, Expression_MaskExpression_MapSelect_MapKeyExpression& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MaskExpression_MapSelect_MapKeyExpression* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MaskExpression_MapSelect_MapKeyExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MaskExpression_MapSelect_MapKeyExpression>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression";
+  }
+  protected:
+  explicit Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMapKeyExpressionFieldNumber = 1,
+  };
+  // string map_key_expression = 1;
+  void clear_map_key_expression();
+  const std::string& map_key_expression() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_map_key_expression(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_map_key_expression();
+  PROTOBUF_NODISCARD std::string* release_map_key_expression();
+  void set_allocated_map_key_expression(std::string* map_key_expression);
+  private:
+  const std::string& _internal_map_key_expression() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_map_key_expression(const std::string& value);
+  std::string* _internal_mutable_map_key_expression();
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_expression_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MaskExpression_MapSelect final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.MapSelect) */ {
+ public:
+  inline Expression_MaskExpression_MapSelect() : Expression_MaskExpression_MapSelect(nullptr) {}
+  ~Expression_MaskExpression_MapSelect() override;
+  explicit constexpr Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MaskExpression_MapSelect(const Expression_MaskExpression_MapSelect& from);
+  Expression_MaskExpression_MapSelect(Expression_MaskExpression_MapSelect&& from) noexcept
+    : Expression_MaskExpression_MapSelect() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MaskExpression_MapSelect& operator=(const Expression_MaskExpression_MapSelect& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MaskExpression_MapSelect& operator=(Expression_MaskExpression_MapSelect&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MaskExpression_MapSelect& default_instance() {
+    return *internal_default_instance();
+  }
+  enum SelectCase {
+    kKey = 1,
+    kExpression = 2,
+    SELECT_NOT_SET = 0,
+  };
+
+  static inline const Expression_MaskExpression_MapSelect* internal_default_instance() {
+    return reinterpret_cast<const Expression_MaskExpression_MapSelect*>(
+               &_Expression_MaskExpression_MapSelect_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    42;
+
+  friend void swap(Expression_MaskExpression_MapSelect& a, Expression_MaskExpression_MapSelect& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MaskExpression_MapSelect* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MaskExpression_MapSelect* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MaskExpression_MapSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MaskExpression_MapSelect>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MaskExpression_MapSelect& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MaskExpression_MapSelect& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MaskExpression_MapSelect* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MaskExpression.MapSelect";
+  }
+  protected:
+  explicit Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_MaskExpression_MapSelect_MapKey MapKey;
+  typedef Expression_MaskExpression_MapSelect_MapKeyExpression MapKeyExpression;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kChildFieldNumber = 3,
+    kKeyFieldNumber = 1,
+    kExpressionFieldNumber = 2,
+  };
+  // .substrait.Expression.MaskExpression.Select child = 3;
+  bool has_child() const;
+  private:
+  bool _internal_has_child() const;
+  public:
+  void clear_child();
+  const ::substrait::Expression_MaskExpression_Select& child() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_Select* release_child();
+  ::substrait::Expression_MaskExpression_Select* mutable_child();
+  void set_allocated_child(::substrait::Expression_MaskExpression_Select* child);
+  private:
+  const ::substrait::Expression_MaskExpression_Select& _internal_child() const;
+  ::substrait::Expression_MaskExpression_Select* _internal_mutable_child();
+  public:
+  void unsafe_arena_set_allocated_child(
+      ::substrait::Expression_MaskExpression_Select* child);
+  ::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child();
+
+  // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::substrait::Expression_MaskExpression_MapSelect_MapKey& key() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_MapSelect_MapKey* release_key();
+  ::substrait::Expression_MaskExpression_MapSelect_MapKey* mutable_key();
+  void set_allocated_key(::substrait::Expression_MaskExpression_MapSelect_MapKey* key);
+  private:
+  const ::substrait::Expression_MaskExpression_MapSelect_MapKey& _internal_key() const;
+  ::substrait::Expression_MaskExpression_MapSelect_MapKey* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::substrait::Expression_MaskExpression_MapSelect_MapKey* key);
+  ::substrait::Expression_MaskExpression_MapSelect_MapKey* unsafe_arena_release_key();
+
+  // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2;
+  bool has_expression() const;
+  private:
+  bool _internal_has_expression() const;
+  public:
+  void clear_expression();
+  const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& expression() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* release_expression();
+  ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* mutable_expression();
+  void set_allocated_expression(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression);
+  private:
+  const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& _internal_expression() const;
+  ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* _internal_mutable_expression();
+  public:
+  void unsafe_arena_set_allocated_expression(
+      ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression);
+  ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* unsafe_arena_release_expression();
+
+  void clear_select();
+  SelectCase select_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.MapSelect)
+ private:
+  class _Internal;
+  void set_has_key();
+  void set_has_expression();
+
+  inline bool has_select() const;
+  inline void clear_has_select();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Expression_MaskExpression_Select* child_;
+  union SelectUnion {
+    constexpr SelectUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Expression_MaskExpression_MapSelect_MapKey* key_;
+    ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression_;
+  } select_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_MaskExpression final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression) */ {
+ public:
+  inline Expression_MaskExpression() : Expression_MaskExpression(nullptr) {}
+  ~Expression_MaskExpression() override;
+  explicit constexpr Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_MaskExpression(const Expression_MaskExpression& from);
+  Expression_MaskExpression(Expression_MaskExpression&& from) noexcept
+    : Expression_MaskExpression() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_MaskExpression& operator=(const Expression_MaskExpression& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_MaskExpression& operator=(Expression_MaskExpression&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_MaskExpression& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_MaskExpression* internal_default_instance() {
+    return reinterpret_cast<const Expression_MaskExpression*>(
+               &_Expression_MaskExpression_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    43;
+
+  friend void swap(Expression_MaskExpression& a, Expression_MaskExpression& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_MaskExpression* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_MaskExpression* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_MaskExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_MaskExpression>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_MaskExpression& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_MaskExpression& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_MaskExpression* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.MaskExpression";
+  }
+  protected:
+  explicit Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_MaskExpression_Select Select;
+  typedef Expression_MaskExpression_StructSelect StructSelect;
+  typedef Expression_MaskExpression_StructItem StructItem;
+  typedef Expression_MaskExpression_ListSelect ListSelect;
+  typedef Expression_MaskExpression_MapSelect MapSelect;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSelectFieldNumber = 1,
+    kMaintainSingularStructFieldNumber = 2,
+  };
+  // .substrait.Expression.MaskExpression.StructSelect select = 1;
+  bool has_select() const;
+  private:
+  bool _internal_has_select() const;
+  public:
+  void clear_select();
+  const ::substrait::Expression_MaskExpression_StructSelect& select() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_StructSelect* release_select();
+  ::substrait::Expression_MaskExpression_StructSelect* mutable_select();
+  void set_allocated_select(::substrait::Expression_MaskExpression_StructSelect* select);
+  private:
+  const ::substrait::Expression_MaskExpression_StructSelect& _internal_select() const;
+  ::substrait::Expression_MaskExpression_StructSelect* _internal_mutable_select();
+  public:
+  void unsafe_arena_set_allocated_select(
+      ::substrait::Expression_MaskExpression_StructSelect* select);
+  ::substrait::Expression_MaskExpression_StructSelect* unsafe_arena_release_select();
+
+  // bool maintain_singular_struct = 2;
+  void clear_maintain_singular_struct();
+  bool maintain_singular_struct() const;
+  void set_maintain_singular_struct(bool value);
+  private:
+  bool _internal_maintain_singular_struct() const;
+  void _internal_set_maintain_singular_struct(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Expression_MaskExpression_StructSelect* select_;
+  bool maintain_singular_struct_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_FieldReference_RootReference final :
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.Expression.FieldReference.RootReference) */ {
+ public:
+  inline Expression_FieldReference_RootReference() : Expression_FieldReference_RootReference(nullptr) {}
+  explicit constexpr Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_FieldReference_RootReference(const Expression_FieldReference_RootReference& from);
+  Expression_FieldReference_RootReference(Expression_FieldReference_RootReference&& from) noexcept
+    : Expression_FieldReference_RootReference() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_FieldReference_RootReference& operator=(const Expression_FieldReference_RootReference& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_FieldReference_RootReference& operator=(Expression_FieldReference_RootReference&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_FieldReference_RootReference& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Expression_FieldReference_RootReference* internal_default_instance() {
+    return reinterpret_cast<const Expression_FieldReference_RootReference*>(
+               &_Expression_FieldReference_RootReference_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    44;
+
+  friend void swap(Expression_FieldReference_RootReference& a, Expression_FieldReference_RootReference& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_FieldReference_RootReference* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_FieldReference_RootReference* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_FieldReference_RootReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_FieldReference_RootReference>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
+  inline void CopyFrom(const Expression_FieldReference_RootReference& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
+  void MergeFrom(const Expression_FieldReference_RootReference& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
+  }
+  public:
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.FieldReference.RootReference";
+  }
+  protected:
+  explicit Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:substrait.Expression.FieldReference.RootReference)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression_FieldReference final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.FieldReference) */ {
+ public:
+  inline Expression_FieldReference() : Expression_FieldReference(nullptr) {}
+  ~Expression_FieldReference() override;
+  explicit constexpr Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression_FieldReference(const Expression_FieldReference& from);
+  Expression_FieldReference(Expression_FieldReference&& from) noexcept
+    : Expression_FieldReference() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression_FieldReference& operator=(const Expression_FieldReference& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression_FieldReference& operator=(Expression_FieldReference&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression_FieldReference& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ReferenceTypeCase {
+    kDirectReference = 1,
+    kMaskedReference = 2,
+    REFERENCE_TYPE_NOT_SET = 0,
+  };
+
+  enum RootTypeCase {
+    kExpression = 3,
+    kRootReference = 4,
+    ROOT_TYPE_NOT_SET = 0,
+  };
+
+  static inline const Expression_FieldReference* internal_default_instance() {
+    return reinterpret_cast<const Expression_FieldReference*>(
+               &_Expression_FieldReference_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    45;
+
+  friend void swap(Expression_FieldReference& a, Expression_FieldReference& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression_FieldReference* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression_FieldReference* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression_FieldReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression_FieldReference>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression_FieldReference& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression_FieldReference& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression_FieldReference* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression.FieldReference";
+  }
+  protected:
+  explicit Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_FieldReference_RootReference RootReference;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDirectReferenceFieldNumber = 1,
+    kMaskedReferenceFieldNumber = 2,
+    kExpressionFieldNumber = 3,
+    kRootReferenceFieldNumber = 4,
+  };
+  // .substrait.Expression.ReferenceSegment direct_reference = 1;
+  bool has_direct_reference() const;
+  private:
+  bool _internal_has_direct_reference() const;
+  public:
+  void clear_direct_reference();
+  const ::substrait::Expression_ReferenceSegment& direct_reference() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment* release_direct_reference();
+  ::substrait::Expression_ReferenceSegment* mutable_direct_reference();
+  void set_allocated_direct_reference(::substrait::Expression_ReferenceSegment* direct_reference);
+  private:
+  const ::substrait::Expression_ReferenceSegment& _internal_direct_reference() const;
+  ::substrait::Expression_ReferenceSegment* _internal_mutable_direct_reference();
+  public:
+  void unsafe_arena_set_allocated_direct_reference(
+      ::substrait::Expression_ReferenceSegment* direct_reference);
+  ::substrait::Expression_ReferenceSegment* unsafe_arena_release_direct_reference();
+
+  // .substrait.Expression.MaskExpression masked_reference = 2;
+  bool has_masked_reference() const;
+  private:
+  bool _internal_has_masked_reference() const;
+  public:
+  void clear_masked_reference();
+  const ::substrait::Expression_MaskExpression& masked_reference() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression* release_masked_reference();
+  ::substrait::Expression_MaskExpression* mutable_masked_reference();
+  void set_allocated_masked_reference(::substrait::Expression_MaskExpression* masked_reference);
+  private:
+  const ::substrait::Expression_MaskExpression& _internal_masked_reference() const;
+  ::substrait::Expression_MaskExpression* _internal_mutable_masked_reference();
+  public:
+  void unsafe_arena_set_allocated_masked_reference(
+      ::substrait::Expression_MaskExpression* masked_reference);
+  ::substrait::Expression_MaskExpression* unsafe_arena_release_masked_reference();
+
+  // .substrait.Expression expression = 3;
+  bool has_expression() const;
+  private:
+  bool _internal_has_expression() const;
+  public:
+  void clear_expression();
+  const ::substrait::Expression& expression() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_expression();
+  ::substrait::Expression* mutable_expression();
+  void set_allocated_expression(::substrait::Expression* expression);
+  private:
+  const ::substrait::Expression& _internal_expression() const;
+  ::substrait::Expression* _internal_mutable_expression();
+  public:
+  void unsafe_arena_set_allocated_expression(
+      ::substrait::Expression* expression);
+  ::substrait::Expression* unsafe_arena_release_expression();
+
+  // .substrait.Expression.FieldReference.RootReference root_reference = 4;
+  bool has_root_reference() const;
+  private:
+  bool _internal_has_root_reference() const;
+  public:
+  void clear_root_reference();
+  const ::substrait::Expression_FieldReference_RootReference& root_reference() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_FieldReference_RootReference* release_root_reference();
+  ::substrait::Expression_FieldReference_RootReference* mutable_root_reference();
+  void set_allocated_root_reference(::substrait::Expression_FieldReference_RootReference* root_reference);
+  private:
+  const ::substrait::Expression_FieldReference_RootReference& _internal_root_reference() const;
+  ::substrait::Expression_FieldReference_RootReference* _internal_mutable_root_reference();
+  public:
+  void unsafe_arena_set_allocated_root_reference(
+      ::substrait::Expression_FieldReference_RootReference* root_reference);
+  ::substrait::Expression_FieldReference_RootReference* unsafe_arena_release_root_reference();
+
+  void clear_reference_type();
+  ReferenceTypeCase reference_type_case() const;
+  void clear_root_type();
+  RootTypeCase root_type_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.Expression.FieldReference)
+ private:
+  class _Internal;
+  void set_has_direct_reference();
+  void set_has_masked_reference();
+  void set_has_expression();
+  void set_has_root_reference();
+
+  inline bool has_reference_type() const;
+  inline void clear_has_reference_type();
+
+  inline bool has_root_type() const;
+  inline void clear_has_root_type();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union ReferenceTypeUnion {
+    constexpr ReferenceTypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Expression_ReferenceSegment* direct_reference_;
+    ::substrait::Expression_MaskExpression* masked_reference_;
+  } reference_type_;
+  union RootTypeUnion {
+    constexpr RootTypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Expression* expression_;
+    ::substrait::Expression_FieldReference_RootReference* root_reference_;
+  } root_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[2];
+
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Expression final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression) */ {
+ public:
+  inline Expression() : Expression(nullptr) {}
+  ~Expression() override;
+  explicit constexpr Expression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Expression(const Expression& from);
+  Expression(Expression&& from) noexcept
+    : Expression() {
+    *this = ::std::move(from);
+  }
+
+  inline Expression& operator=(const Expression& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Expression& operator=(Expression&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Expression& default_instance() {
+    return *internal_default_instance();
+  }
+  enum RexTypeCase {
+    kLiteral = 1,
+    kSelection = 2,
+    kScalarFunction = 3,
+    kWindowFunction = 5,
+    kIfThen = 6,
+    kSwitchExpression = 7,
+    kSingularOrList = 8,
+    kMultiOrList = 9,
+    kEnum = 10,
+    kCast = 11,
+    REX_TYPE_NOT_SET = 0,
+  };
+
+  static inline const Expression* internal_default_instance() {
+    return reinterpret_cast<const Expression*>(
+               &_Expression_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    46;
+
+  friend void swap(Expression& a, Expression& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Expression* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Expression* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Expression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Expression>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Expression& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Expression& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Expression* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Expression";
+  }
+  protected:
+  explicit Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Expression_Enum Enum;
+  typedef Expression_Literal Literal;
+  typedef Expression_ScalarFunction ScalarFunction;
+  typedef Expression_WindowFunction WindowFunction;
+  typedef Expression_IfThen IfThen;
+  typedef Expression_Cast Cast;
+  typedef Expression_SwitchExpression SwitchExpression;
+  typedef Expression_SingularOrList SingularOrList;
+  typedef Expression_MultiOrList MultiOrList;
+  typedef Expression_EmbeddedFunction EmbeddedFunction;
+  typedef Expression_ReferenceSegment ReferenceSegment;
+  typedef Expression_MaskExpression MaskExpression;
+  typedef Expression_FieldReference FieldReference;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLiteralFieldNumber = 1,
+    kSelectionFieldNumber = 2,
+    kScalarFunctionFieldNumber = 3,
+    kWindowFunctionFieldNumber = 5,
+    kIfThenFieldNumber = 6,
+    kSwitchExpressionFieldNumber = 7,
+    kSingularOrListFieldNumber = 8,
+    kMultiOrListFieldNumber = 9,
+    kEnumFieldNumber = 10,
+    kCastFieldNumber = 11,
+  };
+  // .substrait.Expression.Literal literal = 1;
+  bool has_literal() const;
+  private:
+  bool _internal_has_literal() const;
+  public:
+  void clear_literal();
+  const ::substrait::Expression_Literal& literal() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_literal();
+  ::substrait::Expression_Literal* mutable_literal();
+  void set_allocated_literal(::substrait::Expression_Literal* literal);
+  private:
+  const ::substrait::Expression_Literal& _internal_literal() const;
+  ::substrait::Expression_Literal* _internal_mutable_literal();
+  public:
+  void unsafe_arena_set_allocated_literal(
+      ::substrait::Expression_Literal* literal);
+  ::substrait::Expression_Literal* unsafe_arena_release_literal();
+
+  // .substrait.Expression.FieldReference selection = 2;
+  bool has_selection() const;
+  private:
+  bool _internal_has_selection() const;
+  public:
+  void clear_selection();
+  const ::substrait::Expression_FieldReference& selection() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_FieldReference* release_selection();
+  ::substrait::Expression_FieldReference* mutable_selection();
+  void set_allocated_selection(::substrait::Expression_FieldReference* selection);
+  private:
+  const ::substrait::Expression_FieldReference& _internal_selection() const;
+  ::substrait::Expression_FieldReference* _internal_mutable_selection();
+  public:
+  void unsafe_arena_set_allocated_selection(
+      ::substrait::Expression_FieldReference* selection);
+  ::substrait::Expression_FieldReference* unsafe_arena_release_selection();
+
+  // .substrait.Expression.ScalarFunction scalar_function = 3;
+  bool has_scalar_function() const;
+  private:
+  bool _internal_has_scalar_function() const;
+  public:
+  void clear_scalar_function();
+  const ::substrait::Expression_ScalarFunction& scalar_function() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_ScalarFunction* release_scalar_function();
+  ::substrait::Expression_ScalarFunction* mutable_scalar_function();
+  void set_allocated_scalar_function(::substrait::Expression_ScalarFunction* scalar_function);
+  private:
+  const ::substrait::Expression_ScalarFunction& _internal_scalar_function() const;
+  ::substrait::Expression_ScalarFunction* _internal_mutable_scalar_function();
+  public:
+  void unsafe_arena_set_allocated_scalar_function(
+      ::substrait::Expression_ScalarFunction* scalar_function);
+  ::substrait::Expression_ScalarFunction* unsafe_arena_release_scalar_function();
+
+  // .substrait.Expression.WindowFunction window_function = 5;
+  bool has_window_function() const;
+  private:
+  bool _internal_has_window_function() const;
+  public:
+  void clear_window_function();
+  const ::substrait::Expression_WindowFunction& window_function() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction* release_window_function();
+  ::substrait::Expression_WindowFunction* mutable_window_function();
+  void set_allocated_window_function(::substrait::Expression_WindowFunction* window_function);
+  private:
+  const ::substrait::Expression_WindowFunction& _internal_window_function() const;
+  ::substrait::Expression_WindowFunction* _internal_mutable_window_function();
+  public:
+  void unsafe_arena_set_allocated_window_function(
+      ::substrait::Expression_WindowFunction* window_function);
+  ::substrait::Expression_WindowFunction* unsafe_arena_release_window_function();
+
+  // .substrait.Expression.IfThen if_then = 6;
+  bool has_if_then() const;
+  private:
+  bool _internal_has_if_then() const;
+  public:
+  void clear_if_then();
+  const ::substrait::Expression_IfThen& if_then() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_IfThen* release_if_then();
+  ::substrait::Expression_IfThen* mutable_if_then();
+  void set_allocated_if_then(::substrait::Expression_IfThen* if_then);
+  private:
+  const ::substrait::Expression_IfThen& _internal_if_then() const;
+  ::substrait::Expression_IfThen* _internal_mutable_if_then();
+  public:
+  void unsafe_arena_set_allocated_if_then(
+      ::substrait::Expression_IfThen* if_then);
+  ::substrait::Expression_IfThen* unsafe_arena_release_if_then();
+
+  // .substrait.Expression.SwitchExpression switch_expression = 7;
+  bool has_switch_expression() const;
+  private:
+  bool _internal_has_switch_expression() const;
+  public:
+  void clear_switch_expression();
+  const ::substrait::Expression_SwitchExpression& switch_expression() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_SwitchExpression* release_switch_expression();
+  ::substrait::Expression_SwitchExpression* mutable_switch_expression();
+  void set_allocated_switch_expression(::substrait::Expression_SwitchExpression* switch_expression);
+  private:
+  const ::substrait::Expression_SwitchExpression& _internal_switch_expression() const;
+  ::substrait::Expression_SwitchExpression* _internal_mutable_switch_expression();
+  public:
+  void unsafe_arena_set_allocated_switch_expression(
+      ::substrait::Expression_SwitchExpression* switch_expression);
+  ::substrait::Expression_SwitchExpression* unsafe_arena_release_switch_expression();
+
+  // .substrait.Expression.SingularOrList singular_or_list = 8;
+  bool has_singular_or_list() const;
+  private:
+  bool _internal_has_singular_or_list() const;
+  public:
+  void clear_singular_or_list();
+  const ::substrait::Expression_SingularOrList& singular_or_list() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_SingularOrList* release_singular_or_list();
+  ::substrait::Expression_SingularOrList* mutable_singular_or_list();
+  void set_allocated_singular_or_list(::substrait::Expression_SingularOrList* singular_or_list);
+  private:
+  const ::substrait::Expression_SingularOrList& _internal_singular_or_list() const;
+  ::substrait::Expression_SingularOrList* _internal_mutable_singular_or_list();
+  public:
+  void unsafe_arena_set_allocated_singular_or_list(
+      ::substrait::Expression_SingularOrList* singular_or_list);
+  ::substrait::Expression_SingularOrList* unsafe_arena_release_singular_or_list();
+
+  // .substrait.Expression.MultiOrList multi_or_list = 9;
+  bool has_multi_or_list() const;
+  private:
+  bool _internal_has_multi_or_list() const;
+  public:
+  void clear_multi_or_list();
+  const ::substrait::Expression_MultiOrList& multi_or_list() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MultiOrList* release_multi_or_list();
+  ::substrait::Expression_MultiOrList* mutable_multi_or_list();
+  void set_allocated_multi_or_list(::substrait::Expression_MultiOrList* multi_or_list);
+  private:
+  const ::substrait::Expression_MultiOrList& _internal_multi_or_list() const;
+  ::substrait::Expression_MultiOrList* _internal_mutable_multi_or_list();
+  public:
+  void unsafe_arena_set_allocated_multi_or_list(
+      ::substrait::Expression_MultiOrList* multi_or_list);
+  ::substrait::Expression_MultiOrList* unsafe_arena_release_multi_or_list();
+
+  // .substrait.Expression.Enum enum = 10;
+  bool has_enum_() const;
+  private:
+  bool _internal_has_enum_() const;
+  public:
+  void clear_enum_();
+  const ::substrait::Expression_Enum& enum_() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Enum* release_enum_();
+  ::substrait::Expression_Enum* mutable_enum_();
+  void set_allocated_enum_(::substrait::Expression_Enum* enum_);
+  private:
+  const ::substrait::Expression_Enum& _internal_enum_() const;
+  ::substrait::Expression_Enum* _internal_mutable_enum_();
+  public:
+  void unsafe_arena_set_allocated_enum_(
+      ::substrait::Expression_Enum* enum_);
+  ::substrait::Expression_Enum* unsafe_arena_release_enum_();
+
+  // .substrait.Expression.Cast cast = 11;
+  bool has_cast() const;
+  private:
+  bool _internal_has_cast() const;
+  public:
+  void clear_cast();
+  const ::substrait::Expression_Cast& cast() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_Cast* release_cast();
+  ::substrait::Expression_Cast* mutable_cast();
+  void set_allocated_cast(::substrait::Expression_Cast* cast);
+  private:
+  const ::substrait::Expression_Cast& _internal_cast() const;
+  ::substrait::Expression_Cast* _internal_mutable_cast();
+  public:
+  void unsafe_arena_set_allocated_cast(
+      ::substrait::Expression_Cast* cast);
+  ::substrait::Expression_Cast* unsafe_arena_release_cast();
+
+  void clear_rex_type();
+  RexTypeCase rex_type_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.Expression)
+ private:
+  class _Internal;
+  void set_has_literal();
+  void set_has_selection();
+  void set_has_scalar_function();
+  void set_has_window_function();
+  void set_has_if_then();
+  void set_has_switch_expression();
+  void set_has_singular_or_list();
+  void set_has_multi_or_list();
+  void set_has_enum_();
+  void set_has_cast();
+
+  inline bool has_rex_type() const;
+  inline void clear_has_rex_type();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union RexTypeUnion {
+    constexpr RexTypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Expression_Literal* literal_;
+    ::substrait::Expression_FieldReference* selection_;
+    ::substrait::Expression_ScalarFunction* scalar_function_;
+    ::substrait::Expression_WindowFunction* window_function_;
+    ::substrait::Expression_IfThen* if_then_;
+    ::substrait::Expression_SwitchExpression* switch_expression_;
+    ::substrait::Expression_SingularOrList* singular_or_list_;
+    ::substrait::Expression_MultiOrList* multi_or_list_;
+    ::substrait::Expression_Enum* enum__;
+    ::substrait::Expression_Cast* cast_;
+  } rex_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SortField final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.SortField) */ {
+ public:
+  inline SortField() : SortField(nullptr) {}
+  ~SortField() override;
+  explicit constexpr SortField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SortField(const SortField& from);
+  SortField(SortField&& from) noexcept
+    : SortField() {
+    *this = ::std::move(from);
+  }
+
+  inline SortField& operator=(const SortField& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SortField& operator=(SortField&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SortField& default_instance() {
+    return *internal_default_instance();
+  }
+  enum SortKindCase {
+    kDirection = 2,
+    kComparisonFunctionReference = 3,
+    SORT_KIND_NOT_SET = 0,
+  };
+
+  static inline const SortField* internal_default_instance() {
+    return reinterpret_cast<const SortField*>(
+               &_SortField_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    47;
+
+  friend void swap(SortField& a, SortField& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SortField* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SortField* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SortField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SortField>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SortField& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SortField& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SortField* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.SortField";
+  }
+  protected:
+  explicit SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SortField_SortDirection SortDirection;
+  static constexpr SortDirection SORT_DIRECTION_UNSPECIFIED =
+    SortField_SortDirection_SORT_DIRECTION_UNSPECIFIED;
+  static constexpr SortDirection SORT_DIRECTION_ASC_NULLS_FIRST =
+    SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_FIRST;
+  static constexpr SortDirection SORT_DIRECTION_ASC_NULLS_LAST =
+    SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_LAST;
+  static constexpr SortDirection SORT_DIRECTION_DESC_NULLS_FIRST =
+    SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_FIRST;
+  static constexpr SortDirection SORT_DIRECTION_DESC_NULLS_LAST =
+    SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_LAST;
+  static constexpr SortDirection SORT_DIRECTION_CLUSTERED =
+    SortField_SortDirection_SORT_DIRECTION_CLUSTERED;
+  static inline bool SortDirection_IsValid(int value) {
+    return SortField_SortDirection_IsValid(value);
+  }
+  static constexpr SortDirection SortDirection_MIN =
+    SortField_SortDirection_SortDirection_MIN;
+  static constexpr SortDirection SortDirection_MAX =
+    SortField_SortDirection_SortDirection_MAX;
+  static constexpr int SortDirection_ARRAYSIZE =
+    SortField_SortDirection_SortDirection_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  SortDirection_descriptor() {
+    return SortField_SortDirection_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& SortDirection_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SortDirection>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SortDirection_Name.");
+    return SortField_SortDirection_Name(enum_t_value);
+  }
+  static inline bool SortDirection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SortDirection* value) {
+    return SortField_SortDirection_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kExprFieldNumber = 1,
+    kDirectionFieldNumber = 2,
+    kComparisonFunctionReferenceFieldNumber = 3,
+  };
+  // .substrait.Expression expr = 1;
+  bool has_expr() const;
+  private:
+  bool _internal_has_expr() const;
+  public:
+  void clear_expr();
+  const ::substrait::Expression& expr() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_expr();
+  ::substrait::Expression* mutable_expr();
+  void set_allocated_expr(::substrait::Expression* expr);
+  private:
+  const ::substrait::Expression& _internal_expr() const;
+  ::substrait::Expression* _internal_mutable_expr();
+  public:
+  void unsafe_arena_set_allocated_expr(
+      ::substrait::Expression* expr);
+  ::substrait::Expression* unsafe_arena_release_expr();
+
+  // .substrait.SortField.SortDirection direction = 2;
+  bool has_direction() const;
+  private:
+  bool _internal_has_direction() const;
+  public:
+  void clear_direction();
+  ::substrait::SortField_SortDirection direction() const;
+  void set_direction(::substrait::SortField_SortDirection value);
+  private:
+  ::substrait::SortField_SortDirection _internal_direction() const;
+  void _internal_set_direction(::substrait::SortField_SortDirection value);
+  public:
+
+  // uint32 comparison_function_reference = 3;
+  bool has_comparison_function_reference() const;
+  private:
+  bool _internal_has_comparison_function_reference() const;
+  public:
+  void clear_comparison_function_reference();
+  uint32_t comparison_function_reference() const;
+  void set_comparison_function_reference(uint32_t value);
+  private:
+  uint32_t _internal_comparison_function_reference() const;
+  void _internal_set_comparison_function_reference(uint32_t value);
+  public:
+
+  void clear_sort_kind();
+  SortKindCase sort_kind_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.SortField)
+ private:
+  class _Internal;
+  void set_has_direction();
+  void set_has_comparison_function_reference();
+
+  inline bool has_sort_kind() const;
+  inline void clear_has_sort_kind();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Expression* expr_;
+  union SortKindUnion {
+    constexpr SortKindUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    int direction_;
+    uint32_t comparison_function_reference_;
+  } sort_kind_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AggregateFunction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateFunction) */ {
+ public:
+  inline AggregateFunction() : AggregateFunction(nullptr) {}
+  ~AggregateFunction() override;
+  explicit constexpr AggregateFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AggregateFunction(const AggregateFunction& from);
+  AggregateFunction(AggregateFunction&& from) noexcept
+    : AggregateFunction() {
+    *this = ::std::move(from);
+  }
+
+  inline AggregateFunction& operator=(const AggregateFunction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AggregateFunction& operator=(AggregateFunction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AggregateFunction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AggregateFunction* internal_default_instance() {
+    return reinterpret_cast<const AggregateFunction*>(
+               &_AggregateFunction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    48;
+
+  friend void swap(AggregateFunction& a, AggregateFunction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AggregateFunction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AggregateFunction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AggregateFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AggregateFunction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AggregateFunction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const AggregateFunction& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AggregateFunction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.AggregateFunction";
+  }
+  protected:
+  explicit AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kArgsFieldNumber = 2,
+    kSortsFieldNumber = 3,
+    kOutputTypeFieldNumber = 5,
+    kFunctionReferenceFieldNumber = 1,
+    kPhaseFieldNumber = 4,
+  };
+  // repeated .substrait.Expression args = 2;
+  int args_size() const;
+  private:
+  int _internal_args_size() const;
+  public:
+  void clear_args();
+  ::substrait::Expression* mutable_args(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+      mutable_args();
+  private:
+  const ::substrait::Expression& _internal_args(int index) const;
+  ::substrait::Expression* _internal_add_args();
+  public:
+  const ::substrait::Expression& args(int index) const;
+  ::substrait::Expression* add_args();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+      args() const;
+
+  // repeated .substrait.SortField sorts = 3;
+  int sorts_size() const;
+  private:
+  int _internal_sorts_size() const;
+  public:
+  void clear_sorts();
+  ::substrait::SortField* mutable_sorts(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >*
+      mutable_sorts();
+  private:
+  const ::substrait::SortField& _internal_sorts(int index) const;
+  ::substrait::SortField* _internal_add_sorts();
+  public:
+  const ::substrait::SortField& sorts(int index) const;
+  ::substrait::SortField* add_sorts();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >&
+      sorts() const;
+
+  // .substrait.Type output_type = 5;
+  bool has_output_type() const;
+  private:
+  bool _internal_has_output_type() const;
+  public:
+  void clear_output_type();
+  const ::substrait::Type& output_type() const;
+  PROTOBUF_NODISCARD ::substrait::Type* release_output_type();
+  ::substrait::Type* mutable_output_type();
+  void set_allocated_output_type(::substrait::Type* output_type);
+  private:
+  const ::substrait::Type& _internal_output_type() const;
+  ::substrait::Type* _internal_mutable_output_type();
+  public:
+  void unsafe_arena_set_allocated_output_type(
+      ::substrait::Type* output_type);
+  ::substrait::Type* unsafe_arena_release_output_type();
+
+  // uint32 function_reference = 1;
+  void clear_function_reference();
+  uint32_t function_reference() const;
+  void set_function_reference(uint32_t value);
+  private:
+  uint32_t _internal_function_reference() const;
+  void _internal_set_function_reference(uint32_t value);
+  public:
+
+  // .substrait.AggregationPhase phase = 4;
+  void clear_phase();
+  ::substrait::AggregationPhase phase() const;
+  void set_phase(::substrait::AggregationPhase value);
+  private:
+  ::substrait::AggregationPhase _internal_phase() const;
+  void _internal_set_phase(::substrait::AggregationPhase value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.AggregateFunction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > args_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField > sorts_;
+  ::substrait::Type* output_type_;
+  uint32_t function_reference_;
+  int phase_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fexpression_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Expression_Enum_Empty
+
+// -------------------------------------------------------------------
+
+// Expression_Enum
+
+// string specified = 1;
+inline bool Expression_Enum::_internal_has_specified() const {
+  return enum_kind_case() == kSpecified;
+}
+inline bool Expression_Enum::has_specified() const {
+  return _internal_has_specified();
+}
+inline void Expression_Enum::set_has_specified() {
+  _oneof_case_[0] = kSpecified;
+}
+inline void Expression_Enum::clear_specified() {
+  if (_internal_has_specified()) {
+    enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_enum_kind();
+  }
+}
+inline const std::string& Expression_Enum::specified() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Enum.specified)
+  return _internal_specified();
+}
+template <typename ArgT0, typename... ArgT>
+inline void Expression_Enum::set_specified(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_specified()) {
+    clear_enum_kind();
+    set_has_specified();
+    enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Expression.Enum.specified)
+}
+inline std::string* Expression_Enum::mutable_specified() {
+  std::string* _s = _internal_mutable_specified();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Enum.specified)
+  return _s;
+}
+inline const std::string& Expression_Enum::_internal_specified() const {
+  if (_internal_has_specified()) {
+    return enum_kind_.specified_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Expression_Enum::_internal_set_specified(const std::string& value) {
+  if (!_internal_has_specified()) {
+    clear_enum_kind();
+    set_has_specified();
+    enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Expression_Enum::_internal_mutable_specified() {
+  if (!_internal_has_specified()) {
+    clear_enum_kind();
+    set_has_specified();
+    enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return enum_kind_.specified_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Expression_Enum::release_specified() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Enum.specified)
+  if (_internal_has_specified()) {
+    clear_has_enum_kind();
+    return enum_kind_.specified_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Enum::set_allocated_specified(std::string* specified) {
+  if (has_enum_kind()) {
+    clear_enum_kind();
+  }
+  if (specified != nullptr) {
+    set_has_specified();
+    enum_kind_.specified_.UnsafeSetDefault(specified);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(specified);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Enum.specified)
+}
+
+// .substrait.Expression.Enum.Empty unspecified = 2;
+inline bool Expression_Enum::_internal_has_unspecified() const {
+  return enum_kind_case() == kUnspecified;
+}
+inline bool Expression_Enum::has_unspecified() const {
+  return _internal_has_unspecified();
+}
+inline void Expression_Enum::set_has_unspecified() {
+  _oneof_case_[0] = kUnspecified;
+}
+inline void Expression_Enum::clear_unspecified() {
+  if (_internal_has_unspecified()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete enum_kind_.unspecified_;
+    }
+    clear_has_enum_kind();
+  }
+}
+inline ::substrait::Expression_Enum_Empty* Expression_Enum::release_unspecified() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Enum.unspecified)
+  if (_internal_has_unspecified()) {
+    clear_has_enum_kind();
+      ::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    enum_kind_.unspecified_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_Enum_Empty& Expression_Enum::_internal_unspecified() const {
+  return _internal_has_unspecified()
+      ? *enum_kind_.unspecified_
+      : reinterpret_cast< ::substrait::Expression_Enum_Empty&>(::substrait::_Expression_Enum_Empty_default_instance_);
+}
+inline const ::substrait::Expression_Enum_Empty& Expression_Enum::unspecified() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Enum.unspecified)
+  return _internal_unspecified();
+}
+inline ::substrait::Expression_Enum_Empty* Expression_Enum::unsafe_arena_release_unspecified() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Enum.unspecified)
+  if (_internal_has_unspecified()) {
+    clear_has_enum_kind();
+    ::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_;
+    enum_kind_.unspecified_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Enum::unsafe_arena_set_allocated_unspecified(::substrait::Expression_Enum_Empty* unspecified) {
+  clear_enum_kind();
+  if (unspecified) {
+    set_has_unspecified();
+    enum_kind_.unspecified_ = unspecified;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Enum.unspecified)
+}
+inline ::substrait::Expression_Enum_Empty* Expression_Enum::_internal_mutable_unspecified() {
+  if (!_internal_has_unspecified()) {
+    clear_enum_kind();
+    set_has_unspecified();
+    enum_kind_.unspecified_ = CreateMaybeMessage< ::substrait::Expression_Enum_Empty >(GetArenaForAllocation());
+  }
+  return enum_kind_.unspecified_;
+}
+inline ::substrait::Expression_Enum_Empty* Expression_Enum::mutable_unspecified() {
+  ::substrait::Expression_Enum_Empty* _msg = _internal_mutable_unspecified();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Enum.unspecified)
+  return _msg;
+}
+
+inline bool Expression_Enum::has_enum_kind() const {
+  return enum_kind_case() != ENUM_KIND_NOT_SET;
+}
+inline void Expression_Enum::clear_has_enum_kind() {
+  _oneof_case_[0] = ENUM_KIND_NOT_SET;
+}
+inline Expression_Enum::EnumKindCase Expression_Enum::enum_kind_case() const {
+  return Expression_Enum::EnumKindCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Expression_Literal_VarChar
+
+// string value = 1;
+inline void Expression_Literal_VarChar::clear_value() {
+  value_.ClearToEmpty();
+}
+inline const std::string& Expression_Literal_VarChar::value() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.VarChar.value)
+  return _internal_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Expression_Literal_VarChar::set_value(ArgT0&& arg0, ArgT... args) {
+ 
+ value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.VarChar.value)
+}
+inline std::string* Expression_Literal_VarChar::mutable_value() {
+  std::string* _s = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.VarChar.value)
+  return _s;
+}
+inline const std::string& Expression_Literal_VarChar::_internal_value() const {
+  return value_.Get();
+}
+inline void Expression_Literal_VarChar::_internal_set_value(const std::string& value) {
+  
+  value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal_VarChar::_internal_mutable_value() {
+  
+  return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal_VarChar::release_value() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.VarChar.value)
+  return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void Expression_Literal_VarChar::set_allocated_value(std::string* value) {
+  if (value != nullptr) {
+    
+  } else {
+    
+  }
+  value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.VarChar.value)
+}
+
+// uint32 length = 2;
+inline void Expression_Literal_VarChar::clear_length() {
+  length_ = 0u;
+}
+inline uint32_t Expression_Literal_VarChar::_internal_length() const {
+  return length_;
+}
+inline uint32_t Expression_Literal_VarChar::length() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.VarChar.length)
+  return _internal_length();
+}
+inline void Expression_Literal_VarChar::_internal_set_length(uint32_t value) {
+  
+  length_ = value;
+}
+inline void Expression_Literal_VarChar::set_length(uint32_t value) {
+  _internal_set_length(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.VarChar.length)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_Literal_Decimal
+
+// bytes value = 1;
+inline void Expression_Literal_Decimal::clear_value() {
+  value_.ClearToEmpty();
+}
+inline const std::string& Expression_Literal_Decimal::value() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Decimal.value)
+  return _internal_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Expression_Literal_Decimal::set_value(ArgT0&& arg0, ArgT... args) {
+ 
+ value_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.Decimal.value)
+}
+inline std::string* Expression_Literal_Decimal::mutable_value() {
+  std::string* _s = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Decimal.value)
+  return _s;
+}
+inline const std::string& Expression_Literal_Decimal::_internal_value() const {
+  return value_.Get();
+}
+inline void Expression_Literal_Decimal::_internal_set_value(const std::string& value) {
+  
+  value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal_Decimal::_internal_mutable_value() {
+  
+  return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal_Decimal::release_value() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.Decimal.value)
+  return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void Expression_Literal_Decimal::set_allocated_value(std::string* value) {
+  if (value != nullptr) {
+    
+  } else {
+    
+  }
+  value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.Decimal.value)
+}
+
+// int32 precision = 2;
+inline void Expression_Literal_Decimal::clear_precision() {
+  precision_ = 0;
+}
+inline int32_t Expression_Literal_Decimal::_internal_precision() const {
+  return precision_;
+}
+inline int32_t Expression_Literal_Decimal::precision() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Decimal.precision)
+  return _internal_precision();
+}
+inline void Expression_Literal_Decimal::_internal_set_precision(int32_t value) {
+  
+  precision_ = value;
+}
+inline void Expression_Literal_Decimal::set_precision(int32_t value) {
+  _internal_set_precision(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.Decimal.precision)
+}
+
+// int32 scale = 3;
+inline void Expression_Literal_Decimal::clear_scale() {
+  scale_ = 0;
+}
+inline int32_t Expression_Literal_Decimal::_internal_scale() const {
+  return scale_;
+}
+inline int32_t Expression_Literal_Decimal::scale() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Decimal.scale)
+  return _internal_scale();
+}
+inline void Expression_Literal_Decimal::_internal_set_scale(int32_t value) {
+  
+  scale_ = value;
+}
+inline void Expression_Literal_Decimal::set_scale(int32_t value) {
+  _internal_set_scale(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.Decimal.scale)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_Literal_Map_KeyValue
+
+// .substrait.Expression.Literal key = 1;
+inline bool Expression_Literal_Map_KeyValue::_internal_has_key() const {
+  return this != internal_default_instance() && key_ != nullptr;
+}
+inline bool Expression_Literal_Map_KeyValue::has_key() const {
+  return _internal_has_key();
+}
+inline void Expression_Literal_Map_KeyValue::clear_key() {
+  if (GetArenaForAllocation() == nullptr && key_ != nullptr) {
+    delete key_;
+  }
+  key_ = nullptr;
+}
+inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_key() const {
+  const ::substrait::Expression_Literal* p = key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_Literal&>(
+      ::substrait::_Expression_Literal_default_instance_);
+}
+inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::key() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Map.KeyValue.key)
+  return _internal_key();
+}
+inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_key(
+    ::substrait::Expression_Literal* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_);
+  }
+  key_ = key;
+  if (key) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.Map.KeyValue.key)
+}
+inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_key() {
+  
+  ::substrait::Expression_Literal* temp = key_;
+  key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.Map.KeyValue.key)
+  
+  ::substrait::Expression_Literal* temp = key_;
+  key_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_key() {
+  
+  if (key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArenaForAllocation());
+    key_ = p;
+  }
+  return key_;
+}
+inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_key() {
+  ::substrait::Expression_Literal* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Map.KeyValue.key)
+  return _msg;
+}
+inline void Expression_Literal_Map_KeyValue::set_allocated_key(::substrait::Expression_Literal* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.Map.KeyValue.key)
+}
+
+// .substrait.Expression.Literal value = 2;
+inline bool Expression_Literal_Map_KeyValue::_internal_has_value() const {
+  return this != internal_default_instance() && value_ != nullptr;
+}
+inline bool Expression_Literal_Map_KeyValue::has_value() const {
+  return _internal_has_value();
+}
+inline void Expression_Literal_Map_KeyValue::clear_value() {
+  if (GetArenaForAllocation() == nullptr && value_ != nullptr) {
+    delete value_;
+  }
+  value_ = nullptr;
+}
+inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_value() const {
+  const ::substrait::Expression_Literal* p = value_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_Literal&>(
+      ::substrait::_Expression_Literal_default_instance_);
+}
+inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::value() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Map.KeyValue.value)
+  return _internal_value();
+}
+inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_value(
+    ::substrait::Expression_Literal* value) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
+  }
+  value_ = value;
+  if (value) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.Map.KeyValue.value)
+}
+inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_value() {
+  
+  ::substrait::Expression_Literal* temp = value_;
+  value_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.Map.KeyValue.value)
+  
+  ::substrait::Expression_Literal* temp = value_;
+  value_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_value() {
+  
+  if (value_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArenaForAllocation());
+    value_ = p;
+  }
+  return value_;
+}
+inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_value() {
+  ::substrait::Expression_Literal* _msg = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Map.KeyValue.value)
+  return _msg;
+}
+inline void Expression_Literal_Map_KeyValue::set_allocated_value(::substrait::Expression_Literal* value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete value_;
+  }
+  if (value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(value);
+    if (message_arena != submessage_arena) {
+      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  value_ = value;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.Map.KeyValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_Literal_Map
+
+// repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1;
+inline int Expression_Literal_Map::_internal_key_values_size() const {
+  return key_values_.size();
+}
+inline int Expression_Literal_Map::key_values_size() const {
+  return _internal_key_values_size();
+}
+inline void Expression_Literal_Map::clear_key_values() {
+  key_values_.Clear();
+}
+inline ::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::mutable_key_values(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Map.key_values)
+  return key_values_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >*
+Expression_Literal_Map::mutable_key_values() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.Literal.Map.key_values)
+  return &key_values_;
+}
+inline const ::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::_internal_key_values(int index) const {
+  return key_values_.Get(index);
+}
+inline const ::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::key_values(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Map.key_values)
+  return _internal_key_values(index);
+}
+inline ::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::_internal_add_key_values() {
+  return key_values_.Add();
+}
+inline ::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::add_key_values() {
+  ::substrait::Expression_Literal_Map_KeyValue* _add = _internal_add_key_values();
+  // @@protoc_insertion_point(field_add:substrait.Expression.Literal.Map.key_values)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >&
+Expression_Literal_Map::key_values() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.Literal.Map.key_values)
+  return key_values_;
+}
+
+// -------------------------------------------------------------------
+
+// Expression_Literal_IntervalYearToMonth
+
+// int32 years = 1;
+inline void Expression_Literal_IntervalYearToMonth::clear_years() {
+  years_ = 0;
+}
+inline int32_t Expression_Literal_IntervalYearToMonth::_internal_years() const {
+  return years_;
+}
+inline int32_t Expression_Literal_IntervalYearToMonth::years() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalYearToMonth.years)
+  return _internal_years();
+}
+inline void Expression_Literal_IntervalYearToMonth::_internal_set_years(int32_t value) {
+  
+  years_ = value;
+}
+inline void Expression_Literal_IntervalYearToMonth::set_years(int32_t value) {
+  _internal_set_years(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalYearToMonth.years)
+}
+
+// int32 months = 2;
+inline void Expression_Literal_IntervalYearToMonth::clear_months() {
+  months_ = 0;
+}
+inline int32_t Expression_Literal_IntervalYearToMonth::_internal_months() const {
+  return months_;
+}
+inline int32_t Expression_Literal_IntervalYearToMonth::months() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalYearToMonth.months)
+  return _internal_months();
+}
+inline void Expression_Literal_IntervalYearToMonth::_internal_set_months(int32_t value) {
+  
+  months_ = value;
+}
+inline void Expression_Literal_IntervalYearToMonth::set_months(int32_t value) {
+  _internal_set_months(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalYearToMonth.months)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_Literal_IntervalDayToSecond
+
+// int32 days = 1;
+inline void Expression_Literal_IntervalDayToSecond::clear_days() {
+  days_ = 0;
+}
+inline int32_t Expression_Literal_IntervalDayToSecond::_internal_days() const {
+  return days_;
+}
+inline int32_t Expression_Literal_IntervalDayToSecond::days() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalDayToSecond.days)
+  return _internal_days();
+}
+inline void Expression_Literal_IntervalDayToSecond::_internal_set_days(int32_t value) {
+  
+  days_ = value;
+}
+inline void Expression_Literal_IntervalDayToSecond::set_days(int32_t value) {
+  _internal_set_days(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalDayToSecond.days)
+}
+
+// int32 seconds = 2;
+inline void Expression_Literal_IntervalDayToSecond::clear_seconds() {
+  seconds_ = 0;
+}
+inline int32_t Expression_Literal_IntervalDayToSecond::_internal_seconds() const {
+  return seconds_;
+}
+inline int32_t Expression_Literal_IntervalDayToSecond::seconds() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalDayToSecond.seconds)
+  return _internal_seconds();
+}
+inline void Expression_Literal_IntervalDayToSecond::_internal_set_seconds(int32_t value) {
+  
+  seconds_ = value;
+}
+inline void Expression_Literal_IntervalDayToSecond::set_seconds(int32_t value) {
+  _internal_set_seconds(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalDayToSecond.seconds)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_Literal_Struct
+
+// repeated .substrait.Expression.Literal fields = 1;
+inline int Expression_Literal_Struct::_internal_fields_size() const {
+  return fields_.size();
+}
+inline int Expression_Literal_Struct::fields_size() const {
+  return _internal_fields_size();
+}
+inline void Expression_Literal_Struct::clear_fields() {
+  fields_.Clear();
+}
+inline ::substrait::Expression_Literal* Expression_Literal_Struct::mutable_fields(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Struct.fields)
+  return fields_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >*
+Expression_Literal_Struct::mutable_fields() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.Literal.Struct.fields)
+  return &fields_;
+}
+inline const ::substrait::Expression_Literal& Expression_Literal_Struct::_internal_fields(int index) const {
+  return fields_.Get(index);
+}
+inline const ::substrait::Expression_Literal& Expression_Literal_Struct::fields(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Struct.fields)
+  return _internal_fields(index);
+}
+inline ::substrait::Expression_Literal* Expression_Literal_Struct::_internal_add_fields() {
+  return fields_.Add();
+}
+inline ::substrait::Expression_Literal* Expression_Literal_Struct::add_fields() {
+  ::substrait::Expression_Literal* _add = _internal_add_fields();
+  // @@protoc_insertion_point(field_add:substrait.Expression.Literal.Struct.fields)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >&
+Expression_Literal_Struct::fields() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.Literal.Struct.fields)
+  return fields_;
+}
+
+// -------------------------------------------------------------------
+
+// Expression_Literal_List
+
+// repeated .substrait.Expression.Literal values = 1;
+inline int Expression_Literal_List::_internal_values_size() const {
+  return values_.size();
+}
+inline int Expression_Literal_List::values_size() const {
+  return _internal_values_size();
+}
+inline void Expression_Literal_List::clear_values() {
+  values_.Clear();
+}
+inline ::substrait::Expression_Literal* Expression_Literal_List::mutable_values(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.List.values)
+  return values_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >*
+Expression_Literal_List::mutable_values() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.Literal.List.values)
+  return &values_;
+}
+inline const ::substrait::Expression_Literal& Expression_Literal_List::_internal_values(int index) const {
+  return values_.Get(index);
+}
+inline const ::substrait::Expression_Literal& Expression_Literal_List::values(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.List.values)
+  return _internal_values(index);
+}
+inline ::substrait::Expression_Literal* Expression_Literal_List::_internal_add_values() {
+  return values_.Add();
+}
+inline ::substrait::Expression_Literal* Expression_Literal_List::add_values() {
+  ::substrait::Expression_Literal* _add = _internal_add_values();
+  // @@protoc_insertion_point(field_add:substrait.Expression.Literal.List.values)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >&
+Expression_Literal_List::values() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.Literal.List.values)
+  return values_;
+}
+
+// -------------------------------------------------------------------
+
+// Expression_Literal
+
+// bool boolean = 1;
+inline bool Expression_Literal::_internal_has_boolean() const {
+  return literal_type_case() == kBoolean;
+}
+inline bool Expression_Literal::has_boolean() const {
+  return _internal_has_boolean();
+}
+inline void Expression_Literal::set_has_boolean() {
+  _oneof_case_[0] = kBoolean;
+}
+inline void Expression_Literal::clear_boolean() {
+  if (_internal_has_boolean()) {
+    literal_type_.boolean_ = false;
+    clear_has_literal_type();
+  }
+}
+inline bool Expression_Literal::_internal_boolean() const {
+  if (_internal_has_boolean()) {
+    return literal_type_.boolean_;
+  }
+  return false;
+}
+inline void Expression_Literal::_internal_set_boolean(bool value) {
+  if (!_internal_has_boolean()) {
+    clear_literal_type();
+    set_has_boolean();
+  }
+  literal_type_.boolean_ = value;
+}
+inline bool Expression_Literal::boolean() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.boolean)
+  return _internal_boolean();
+}
+inline void Expression_Literal::set_boolean(bool value) {
+  _internal_set_boolean(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.boolean)
+}
+
+// int32 i8 = 2;
+inline bool Expression_Literal::_internal_has_i8() const {
+  return literal_type_case() == kI8;
+}
+inline bool Expression_Literal::has_i8() const {
+  return _internal_has_i8();
+}
+inline void Expression_Literal::set_has_i8() {
+  _oneof_case_[0] = kI8;
+}
+inline void Expression_Literal::clear_i8() {
+  if (_internal_has_i8()) {
+    literal_type_.i8_ = 0;
+    clear_has_literal_type();
+  }
+}
+inline int32_t Expression_Literal::_internal_i8() const {
+  if (_internal_has_i8()) {
+    return literal_type_.i8_;
+  }
+  return 0;
+}
+inline void Expression_Literal::_internal_set_i8(int32_t value) {
+  if (!_internal_has_i8()) {
+    clear_literal_type();
+    set_has_i8();
+  }
+  literal_type_.i8_ = value;
+}
+inline int32_t Expression_Literal::i8() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i8)
+  return _internal_i8();
+}
+inline void Expression_Literal::set_i8(int32_t value) {
+  _internal_set_i8(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i8)
+}
+
+// int32 i16 = 3;
+inline bool Expression_Literal::_internal_has_i16() const {
+  return literal_type_case() == kI16;
+}
+inline bool Expression_Literal::has_i16() const {
+  return _internal_has_i16();
+}
+inline void Expression_Literal::set_has_i16() {
+  _oneof_case_[0] = kI16;
+}
+inline void Expression_Literal::clear_i16() {
+  if (_internal_has_i16()) {
+    literal_type_.i16_ = 0;
+    clear_has_literal_type();
+  }
+}
+inline int32_t Expression_Literal::_internal_i16() const {
+  if (_internal_has_i16()) {
+    return literal_type_.i16_;
+  }
+  return 0;
+}
+inline void Expression_Literal::_internal_set_i16(int32_t value) {
+  if (!_internal_has_i16()) {
+    clear_literal_type();
+    set_has_i16();
+  }
+  literal_type_.i16_ = value;
+}
+inline int32_t Expression_Literal::i16() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i16)
+  return _internal_i16();
+}
+inline void Expression_Literal::set_i16(int32_t value) {
+  _internal_set_i16(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i16)
+}
+
+// int32 i32 = 5;
+inline bool Expression_Literal::_internal_has_i32() const {
+  return literal_type_case() == kI32;
+}
+inline bool Expression_Literal::has_i32() const {
+  return _internal_has_i32();
+}
+inline void Expression_Literal::set_has_i32() {
+  _oneof_case_[0] = kI32;
+}
+inline void Expression_Literal::clear_i32() {
+  if (_internal_has_i32()) {
+    literal_type_.i32_ = 0;
+    clear_has_literal_type();
+  }
+}
+inline int32_t Expression_Literal::_internal_i32() const {
+  if (_internal_has_i32()) {
+    return literal_type_.i32_;
+  }
+  return 0;
+}
+inline void Expression_Literal::_internal_set_i32(int32_t value) {
+  if (!_internal_has_i32()) {
+    clear_literal_type();
+    set_has_i32();
+  }
+  literal_type_.i32_ = value;
+}
+inline int32_t Expression_Literal::i32() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i32)
+  return _internal_i32();
+}
+inline void Expression_Literal::set_i32(int32_t value) {
+  _internal_set_i32(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i32)
+}
+
+// int64 i64 = 7;
+inline bool Expression_Literal::_internal_has_i64() const {
+  return literal_type_case() == kI64;
+}
+inline bool Expression_Literal::has_i64() const {
+  return _internal_has_i64();
+}
+inline void Expression_Literal::set_has_i64() {
+  _oneof_case_[0] = kI64;
+}
+inline void Expression_Literal::clear_i64() {
+  if (_internal_has_i64()) {
+    literal_type_.i64_ = int64_t{0};
+    clear_has_literal_type();
+  }
+}
+inline int64_t Expression_Literal::_internal_i64() const {
+  if (_internal_has_i64()) {
+    return literal_type_.i64_;
+  }
+  return int64_t{0};
+}
+inline void Expression_Literal::_internal_set_i64(int64_t value) {
+  if (!_internal_has_i64()) {
+    clear_literal_type();
+    set_has_i64();
+  }
+  literal_type_.i64_ = value;
+}
+inline int64_t Expression_Literal::i64() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i64)
+  return _internal_i64();
+}
+inline void Expression_Literal::set_i64(int64_t value) {
+  _internal_set_i64(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i64)
+}
+
+// float fp32 = 10;
+inline bool Expression_Literal::_internal_has_fp32() const {
+  return literal_type_case() == kFp32;
+}
+inline bool Expression_Literal::has_fp32() const {
+  return _internal_has_fp32();
+}
+inline void Expression_Literal::set_has_fp32() {
+  _oneof_case_[0] = kFp32;
+}
+inline void Expression_Literal::clear_fp32() {
+  if (_internal_has_fp32()) {
+    literal_type_.fp32_ = 0;
+    clear_has_literal_type();
+  }
+}
+inline float Expression_Literal::_internal_fp32() const {
+  if (_internal_has_fp32()) {
+    return literal_type_.fp32_;
+  }
+  return 0;
+}
+inline void Expression_Literal::_internal_set_fp32(float value) {
+  if (!_internal_has_fp32()) {
+    clear_literal_type();
+    set_has_fp32();
+  }
+  literal_type_.fp32_ = value;
+}
+inline float Expression_Literal::fp32() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.fp32)
+  return _internal_fp32();
+}
+inline void Expression_Literal::set_fp32(float value) {
+  _internal_set_fp32(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fp32)
+}
+
+// double fp64 = 11;
+inline bool Expression_Literal::_internal_has_fp64() const {
+  return literal_type_case() == kFp64;
+}
+inline bool Expression_Literal::has_fp64() const {
+  return _internal_has_fp64();
+}
+inline void Expression_Literal::set_has_fp64() {
+  _oneof_case_[0] = kFp64;
+}
+inline void Expression_Literal::clear_fp64() {
+  if (_internal_has_fp64()) {
+    literal_type_.fp64_ = 0;
+    clear_has_literal_type();
+  }
+}
+inline double Expression_Literal::_internal_fp64() const {
+  if (_internal_has_fp64()) {
+    return literal_type_.fp64_;
+  }
+  return 0;
+}
+inline void Expression_Literal::_internal_set_fp64(double value) {
+  if (!_internal_has_fp64()) {
+    clear_literal_type();
+    set_has_fp64();
+  }
+  literal_type_.fp64_ = value;
+}
+inline double Expression_Literal::fp64() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.fp64)
+  return _internal_fp64();
+}
+inline void Expression_Literal::set_fp64(double value) {
+  _internal_set_fp64(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fp64)
+}
+
+// string string = 12;
+inline bool Expression_Literal::_internal_has_string() const {
+  return literal_type_case() == kString;
+}
+inline bool Expression_Literal::has_string() const {
+  return _internal_has_string();
+}
+inline void Expression_Literal::set_has_string() {
+  _oneof_case_[0] = kString;
+}
+inline void Expression_Literal::clear_string() {
+  if (_internal_has_string()) {
+    literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_literal_type();
+  }
+}
+inline const std::string& Expression_Literal::string() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.string)
+  return _internal_string();
+}
+template <typename ArgT0, typename... ArgT>
+inline void Expression_Literal::set_string(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_string()) {
+    clear_literal_type();
+    set_has_string();
+    literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.string)
+}
+inline std::string* Expression_Literal::mutable_string() {
+  std::string* _s = _internal_mutable_string();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.string)
+  return _s;
+}
+inline const std::string& Expression_Literal::_internal_string() const {
+  if (_internal_has_string()) {
+    return literal_type_.string_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Expression_Literal::_internal_set_string(const std::string& value) {
+  if (!_internal_has_string()) {
+    clear_literal_type();
+    set_has_string();
+    literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal::_internal_mutable_string() {
+  if (!_internal_has_string()) {
+    clear_literal_type();
+    set_has_string();
+    literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return literal_type_.string_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal::release_string() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.string)
+  if (_internal_has_string()) {
+    clear_has_literal_type();
+    return literal_type_.string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::set_allocated_string(std::string* string) {
+  if (has_literal_type()) {
+    clear_literal_type();
+  }
+  if (string != nullptr) {
+    set_has_string();
+    literal_type_.string_.UnsafeSetDefault(string);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(string);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.string)
+}
+
+// bytes binary = 13;
+inline bool Expression_Literal::_internal_has_binary() const {
+  return literal_type_case() == kBinary;
+}
+inline bool Expression_Literal::has_binary() const {
+  return _internal_has_binary();
+}
+inline void Expression_Literal::set_has_binary() {
+  _oneof_case_[0] = kBinary;
+}
+inline void Expression_Literal::clear_binary() {
+  if (_internal_has_binary()) {
+    literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_literal_type();
+  }
+}
+inline const std::string& Expression_Literal::binary() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.binary)
+  return _internal_binary();
+}
+template <typename ArgT0, typename... ArgT>
+inline void Expression_Literal::set_binary(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_binary()) {
+    clear_literal_type();
+    set_has_binary();
+    literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  literal_type_.binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.binary)
+}
+inline std::string* Expression_Literal::mutable_binary() {
+  std::string* _s = _internal_mutable_binary();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.binary)
+  return _s;
+}
+inline const std::string& Expression_Literal::_internal_binary() const {
+  if (_internal_has_binary()) {
+    return literal_type_.binary_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Expression_Literal::_internal_set_binary(const std::string& value) {
+  if (!_internal_has_binary()) {
+    clear_literal_type();
+    set_has_binary();
+    literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  literal_type_.binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal::_internal_mutable_binary() {
+  if (!_internal_has_binary()) {
+    clear_literal_type();
+    set_has_binary();
+    literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return literal_type_.binary_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal::release_binary() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.binary)
+  if (_internal_has_binary()) {
+    clear_has_literal_type();
+    return literal_type_.binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::set_allocated_binary(std::string* binary) {
+  if (has_literal_type()) {
+    clear_literal_type();
+  }
+  if (binary != nullptr) {
+    set_has_binary();
+    literal_type_.binary_.UnsafeSetDefault(binary);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(binary);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.binary)
+}
+
+// int64 timestamp = 14;
+inline bool Expression_Literal::_internal_has_timestamp() const {
+  return literal_type_case() == kTimestamp;
+}
+inline bool Expression_Literal::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void Expression_Literal::set_has_timestamp() {
+  _oneof_case_[0] = kTimestamp;
+}
+inline void Expression_Literal::clear_timestamp() {
+  if (_internal_has_timestamp()) {
+    literal_type_.timestamp_ = int64_t{0};
+    clear_has_literal_type();
+  }
+}
+inline int64_t Expression_Literal::_internal_timestamp() const {
+  if (_internal_has_timestamp()) {
+    return literal_type_.timestamp_;
+  }
+  return int64_t{0};
+}
+inline void Expression_Literal::_internal_set_timestamp(int64_t value) {
+  if (!_internal_has_timestamp()) {
+    clear_literal_type();
+    set_has_timestamp();
+  }
+  literal_type_.timestamp_ = value;
+}
+inline int64_t Expression_Literal::timestamp() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.timestamp)
+  return _internal_timestamp();
+}
+inline void Expression_Literal::set_timestamp(int64_t value) {
+  _internal_set_timestamp(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.timestamp)
+}
+
+// int32 date = 16;
+inline bool Expression_Literal::_internal_has_date() const {
+  return literal_type_case() == kDate;
+}
+inline bool Expression_Literal::has_date() const {
+  return _internal_has_date();
+}
+inline void Expression_Literal::set_has_date() {
+  _oneof_case_[0] = kDate;
+}
+inline void Expression_Literal::clear_date() {
+  if (_internal_has_date()) {
+    literal_type_.date_ = 0;
+    clear_has_literal_type();
+  }
+}
+inline int32_t Expression_Literal::_internal_date() const {
+  if (_internal_has_date()) {
+    return literal_type_.date_;
+  }
+  return 0;
+}
+inline void Expression_Literal::_internal_set_date(int32_t value) {
+  if (!_internal_has_date()) {
+    clear_literal_type();
+    set_has_date();
+  }
+  literal_type_.date_ = value;
+}
+inline int32_t Expression_Literal::date() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.date)
+  return _internal_date();
+}
+inline void Expression_Literal::set_date(int32_t value) {
+  _internal_set_date(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.date)
+}
+
+// int64 time = 17;
+inline bool Expression_Literal::_internal_has_time() const {
+  return literal_type_case() == kTime;
+}
+inline bool Expression_Literal::has_time() const {
+  return _internal_has_time();
+}
+inline void Expression_Literal::set_has_time() {
+  _oneof_case_[0] = kTime;
+}
+inline void Expression_Literal::clear_time() {
+  if (_internal_has_time()) {
+    literal_type_.time_ = int64_t{0};
+    clear_has_literal_type();
+  }
+}
+inline int64_t Expression_Literal::_internal_time() const {
+  if (_internal_has_time()) {
+    return literal_type_.time_;
+  }
+  return int64_t{0};
+}
+inline void Expression_Literal::_internal_set_time(int64_t value) {
+  if (!_internal_has_time()) {
+    clear_literal_type();
+    set_has_time();
+  }
+  literal_type_.time_ = value;
+}
+inline int64_t Expression_Literal::time() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.time)
+  return _internal_time();
+}
+inline void Expression_Literal::set_time(int64_t value) {
+  _internal_set_time(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.time)
+}
+
+// .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19;
+inline bool Expression_Literal::_internal_has_interval_year_to_month() const {
+  return literal_type_case() == kIntervalYearToMonth;
+}
+inline bool Expression_Literal::has_interval_year_to_month() const {
+  return _internal_has_interval_year_to_month();
+}
+inline void Expression_Literal::set_has_interval_year_to_month() {
+  _oneof_case_[0] = kIntervalYearToMonth;
+}
+inline void Expression_Literal::clear_interval_year_to_month() {
+  if (_internal_has_interval_year_to_month()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete literal_type_.interval_year_to_month_;
+    }
+    clear_has_literal_type();
+  }
+}
+inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::release_interval_year_to_month() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.interval_year_to_month)
+  if (_internal_has_interval_year_to_month()) {
+    clear_has_literal_type();
+      ::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    literal_type_.interval_year_to_month_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::_internal_interval_year_to_month() const {
+  return _internal_has_interval_year_to_month()
+      ? *literal_type_.interval_year_to_month_
+      : reinterpret_cast< ::substrait::Expression_Literal_IntervalYearToMonth&>(::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_);
+}
+inline const ::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::interval_year_to_month() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.interval_year_to_month)
+  return _internal_interval_year_to_month();
+}
+inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::unsafe_arena_release_interval_year_to_month() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.interval_year_to_month)
+  if (_internal_has_interval_year_to_month()) {
+    clear_has_literal_type();
+    ::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_;
+    literal_type_.interval_year_to_month_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::unsafe_arena_set_allocated_interval_year_to_month(::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) {
+  clear_literal_type();
+  if (interval_year_to_month) {
+    set_has_interval_year_to_month();
+    literal_type_.interval_year_to_month_ = interval_year_to_month;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.interval_year_to_month)
+}
+inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::_internal_mutable_interval_year_to_month() {
+  if (!_internal_has_interval_year_to_month()) {
+    clear_literal_type();
+    set_has_interval_year_to_month();
+    literal_type_.interval_year_to_month_ = CreateMaybeMessage< ::substrait::Expression_Literal_IntervalYearToMonth >(GetArenaForAllocation());
+  }
+  return literal_type_.interval_year_to_month_;
+}
+inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::mutable_interval_year_to_month() {
+  ::substrait::Expression_Literal_IntervalYearToMonth* _msg = _internal_mutable_interval_year_to_month();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.interval_year_to_month)
+  return _msg;
+}
+
+// .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20;
+inline bool Expression_Literal::_internal_has_interval_day_to_second() const {
+  return literal_type_case() == kIntervalDayToSecond;
+}
+inline bool Expression_Literal::has_interval_day_to_second() const {
+  return _internal_has_interval_day_to_second();
+}
+inline void Expression_Literal::set_has_interval_day_to_second() {
+  _oneof_case_[0] = kIntervalDayToSecond;
+}
+inline void Expression_Literal::clear_interval_day_to_second() {
+  if (_internal_has_interval_day_to_second()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete literal_type_.interval_day_to_second_;
+    }
+    clear_has_literal_type();
+  }
+}
+inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::release_interval_day_to_second() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.interval_day_to_second)
+  if (_internal_has_interval_day_to_second()) {
+    clear_has_literal_type();
+      ::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    literal_type_.interval_day_to_second_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::_internal_interval_day_to_second() const {
+  return _internal_has_interval_day_to_second()
+      ? *literal_type_.interval_day_to_second_
+      : reinterpret_cast< ::substrait::Expression_Literal_IntervalDayToSecond&>(::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_);
+}
+inline const ::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::interval_day_to_second() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.interval_day_to_second)
+  return _internal_interval_day_to_second();
+}
+inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::unsafe_arena_release_interval_day_to_second() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.interval_day_to_second)
+  if (_internal_has_interval_day_to_second()) {
+    clear_has_literal_type();
+    ::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_;
+    literal_type_.interval_day_to_second_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::unsafe_arena_set_allocated_interval_day_to_second(::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) {
+  clear_literal_type();
+  if (interval_day_to_second) {
+    set_has_interval_day_to_second();
+    literal_type_.interval_day_to_second_ = interval_day_to_second;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.interval_day_to_second)
+}
+inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::_internal_mutable_interval_day_to_second() {
+  if (!_internal_has_interval_day_to_second()) {
+    clear_literal_type();
+    set_has_interval_day_to_second();
+    literal_type_.interval_day_to_second_ = CreateMaybeMessage< ::substrait::Expression_Literal_IntervalDayToSecond >(GetArenaForAllocation());
+  }
+  return literal_type_.interval_day_to_second_;
+}
+inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::mutable_interval_day_to_second() {
+  ::substrait::Expression_Literal_IntervalDayToSecond* _msg = _internal_mutable_interval_day_to_second();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.interval_day_to_second)
+  return _msg;
+}
+
+// string fixed_char = 21;
+inline bool Expression_Literal::_internal_has_fixed_char() const {
+  return literal_type_case() == kFixedChar;
+}
+inline bool Expression_Literal::has_fixed_char() const {
+  return _internal_has_fixed_char();
+}
+inline void Expression_Literal::set_has_fixed_char() {
+  _oneof_case_[0] = kFixedChar;
+}
+inline void Expression_Literal::clear_fixed_char() {
+  if (_internal_has_fixed_char()) {
+    literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_literal_type();
+  }
+}
+inline const std::string& Expression_Literal::fixed_char() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.fixed_char)
+  return _internal_fixed_char();
+}
+template <typename ArgT0, typename... ArgT>
+inline void Expression_Literal::set_fixed_char(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_fixed_char()) {
+    clear_literal_type();
+    set_has_fixed_char();
+    literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fixed_char)
+}
+inline std::string* Expression_Literal::mutable_fixed_char() {
+  std::string* _s = _internal_mutable_fixed_char();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.fixed_char)
+  return _s;
+}
+inline const std::string& Expression_Literal::_internal_fixed_char() const {
+  if (_internal_has_fixed_char()) {
+    return literal_type_.fixed_char_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Expression_Literal::_internal_set_fixed_char(const std::string& value) {
+  if (!_internal_has_fixed_char()) {
+    clear_literal_type();
+    set_has_fixed_char();
+    literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal::_internal_mutable_fixed_char() {
+  if (!_internal_has_fixed_char()) {
+    clear_literal_type();
+    set_has_fixed_char();
+    literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return literal_type_.fixed_char_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal::release_fixed_char() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.fixed_char)
+  if (_internal_has_fixed_char()) {
+    clear_has_literal_type();
+    return literal_type_.fixed_char_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::set_allocated_fixed_char(std::string* fixed_char) {
+  if (has_literal_type()) {
+    clear_literal_type();
+  }
+  if (fixed_char != nullptr) {
+    set_has_fixed_char();
+    literal_type_.fixed_char_.UnsafeSetDefault(fixed_char);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(fixed_char);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.fixed_char)
+}
+
+// .substrait.Expression.Literal.VarChar var_char = 22;
+inline bool Expression_Literal::_internal_has_var_char() const {
+  return literal_type_case() == kVarChar;
+}
+inline bool Expression_Literal::has_var_char() const {
+  return _internal_has_var_char();
+}
+inline void Expression_Literal::set_has_var_char() {
+  _oneof_case_[0] = kVarChar;
+}
+inline void Expression_Literal::clear_var_char() {
+  if (_internal_has_var_char()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete literal_type_.var_char_;
+    }
+    clear_has_literal_type();
+  }
+}
+inline ::substrait::Expression_Literal_VarChar* Expression_Literal::release_var_char() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.var_char)
+  if (_internal_has_var_char()) {
+    clear_has_literal_type();
+      ::substrait::Expression_Literal_VarChar* temp = literal_type_.var_char_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    literal_type_.var_char_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_Literal_VarChar& Expression_Literal::_internal_var_char() const {
+  return _internal_has_var_char()
+      ? *literal_type_.var_char_
+      : reinterpret_cast< ::substrait::Expression_Literal_VarChar&>(::substrait::_Expression_Literal_VarChar_default_instance_);
+}
+inline const ::substrait::Expression_Literal_VarChar& Expression_Literal::var_char() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.var_char)
+  return _internal_var_char();
+}
+inline ::substrait::Expression_Literal_VarChar* Expression_Literal::unsafe_arena_release_var_char() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.var_char)
+  if (_internal_has_var_char()) {
+    clear_has_literal_type();
+    ::substrait::Expression_Literal_VarChar* temp = literal_type_.var_char_;
+    literal_type_.var_char_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::unsafe_arena_set_allocated_var_char(::substrait::Expression_Literal_VarChar* var_char) {
+  clear_literal_type();
+  if (var_char) {
+    set_has_var_char();
+    literal_type_.var_char_ = var_char;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.var_char)
+}
+inline ::substrait::Expression_Literal_VarChar* Expression_Literal::_internal_mutable_var_char() {
+  if (!_internal_has_var_char()) {
+    clear_literal_type();
+    set_has_var_char();
+    literal_type_.var_char_ = CreateMaybeMessage< ::substrait::Expression_Literal_VarChar >(GetArenaForAllocation());
+  }
+  return literal_type_.var_char_;
+}
+inline ::substrait::Expression_Literal_VarChar* Expression_Literal::mutable_var_char() {
+  ::substrait::Expression_Literal_VarChar* _msg = _internal_mutable_var_char();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.var_char)
+  return _msg;
+}
+
+// bytes fixed_binary = 23;
+inline bool Expression_Literal::_internal_has_fixed_binary() const {
+  return literal_type_case() == kFixedBinary;
+}
+inline bool Expression_Literal::has_fixed_binary() const {
+  return _internal_has_fixed_binary();
+}
+inline void Expression_Literal::set_has_fixed_binary() {
+  _oneof_case_[0] = kFixedBinary;
+}
+inline void Expression_Literal::clear_fixed_binary() {
+  if (_internal_has_fixed_binary()) {
+    literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_literal_type();
+  }
+}
+inline const std::string& Expression_Literal::fixed_binary() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.fixed_binary)
+  return _internal_fixed_binary();
+}
+template <typename ArgT0, typename... ArgT>
+inline void Expression_Literal::set_fixed_binary(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_fixed_binary()) {
+    clear_literal_type();
+    set_has_fixed_binary();
+    literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  literal_type_.fixed_binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fixed_binary)
+}
+inline std::string* Expression_Literal::mutable_fixed_binary() {
+  std::string* _s = _internal_mutable_fixed_binary();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.fixed_binary)
+  return _s;
+}
+inline const std::string& Expression_Literal::_internal_fixed_binary() const {
+  if (_internal_has_fixed_binary()) {
+    return literal_type_.fixed_binary_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Expression_Literal::_internal_set_fixed_binary(const std::string& value) {
+  if (!_internal_has_fixed_binary()) {
+    clear_literal_type();
+    set_has_fixed_binary();
+    literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  literal_type_.fixed_binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal::_internal_mutable_fixed_binary() {
+  if (!_internal_has_fixed_binary()) {
+    clear_literal_type();
+    set_has_fixed_binary();
+    literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return literal_type_.fixed_binary_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal::release_fixed_binary() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.fixed_binary)
+  if (_internal_has_fixed_binary()) {
+    clear_has_literal_type();
+    return literal_type_.fixed_binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::set_allocated_fixed_binary(std::string* fixed_binary) {
+  if (has_literal_type()) {
+    clear_literal_type();
+  }
+  if (fixed_binary != nullptr) {
+    set_has_fixed_binary();
+    literal_type_.fixed_binary_.UnsafeSetDefault(fixed_binary);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(fixed_binary);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.fixed_binary)
+}
+
+// .substrait.Expression.Literal.Decimal decimal = 24;
+inline bool Expression_Literal::_internal_has_decimal() const {
+  return literal_type_case() == kDecimal;
+}
+inline bool Expression_Literal::has_decimal() const {
+  return _internal_has_decimal();
+}
+inline void Expression_Literal::set_has_decimal() {
+  _oneof_case_[0] = kDecimal;
+}
+inline void Expression_Literal::clear_decimal() {
+  if (_internal_has_decimal()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete literal_type_.decimal_;
+    }
+    clear_has_literal_type();
+  }
+}
+inline ::substrait::Expression_Literal_Decimal* Expression_Literal::release_decimal() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.decimal)
+  if (_internal_has_decimal()) {
+    clear_has_literal_type();
+      ::substrait::Expression_Literal_Decimal* temp = literal_type_.decimal_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    literal_type_.decimal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_Literal_Decimal& Expression_Literal::_internal_decimal() const {
+  return _internal_has_decimal()
+      ? *literal_type_.decimal_
+      : reinterpret_cast< ::substrait::Expression_Literal_Decimal&>(::substrait::_Expression_Literal_Decimal_default_instance_);
+}
+inline const ::substrait::Expression_Literal_Decimal& Expression_Literal::decimal() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.decimal)
+  return _internal_decimal();
+}
+inline ::substrait::Expression_Literal_Decimal* Expression_Literal::unsafe_arena_release_decimal() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.decimal)
+  if (_internal_has_decimal()) {
+    clear_has_literal_type();
+    ::substrait::Expression_Literal_Decimal* temp = literal_type_.decimal_;
+    literal_type_.decimal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::unsafe_arena_set_allocated_decimal(::substrait::Expression_Literal_Decimal* decimal) {
+  clear_literal_type();
+  if (decimal) {
+    set_has_decimal();
+    literal_type_.decimal_ = decimal;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.decimal)
+}
+inline ::substrait::Expression_Literal_Decimal* Expression_Literal::_internal_mutable_decimal() {
+  if (!_internal_has_decimal()) {
+    clear_literal_type();
+    set_has_decimal();
+    literal_type_.decimal_ = CreateMaybeMessage< ::substrait::Expression_Literal_Decimal >(GetArenaForAllocation());
+  }
+  return literal_type_.decimal_;
+}
+inline ::substrait::Expression_Literal_Decimal* Expression_Literal::mutable_decimal() {
+  ::substrait::Expression_Literal_Decimal* _msg = _internal_mutable_decimal();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.decimal)
+  return _msg;
+}
+
+// .substrait.Expression.Literal.Struct struct = 25;
+inline bool Expression_Literal::_internal_has_struct_() const {
+  return literal_type_case() == kStruct;
+}
+inline bool Expression_Literal::has_struct_() const {
+  return _internal_has_struct_();
+}
+inline void Expression_Literal::set_has_struct_() {
+  _oneof_case_[0] = kStruct;
+}
+inline void Expression_Literal::clear_struct_() {
+  if (_internal_has_struct_()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete literal_type_.struct__;
+    }
+    clear_has_literal_type();
+  }
+}
+inline ::substrait::Expression_Literal_Struct* Expression_Literal::release_struct_() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.struct)
+  if (_internal_has_struct_()) {
+    clear_has_literal_type();
+      ::substrait::Expression_Literal_Struct* temp = literal_type_.struct__;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    literal_type_.struct__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_Literal_Struct& Expression_Literal::_internal_struct_() const {
+  return _internal_has_struct_()
+      ? *literal_type_.struct__
+      : reinterpret_cast< ::substrait::Expression_Literal_Struct&>(::substrait::_Expression_Literal_Struct_default_instance_);
+}
+inline const ::substrait::Expression_Literal_Struct& Expression_Literal::struct_() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.struct)
+  return _internal_struct_();
+}
+inline ::substrait::Expression_Literal_Struct* Expression_Literal::unsafe_arena_release_struct_() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.struct)
+  if (_internal_has_struct_()) {
+    clear_has_literal_type();
+    ::substrait::Expression_Literal_Struct* temp = literal_type_.struct__;
+    literal_type_.struct__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::unsafe_arena_set_allocated_struct_(::substrait::Expression_Literal_Struct* struct_) {
+  clear_literal_type();
+  if (struct_) {
+    set_has_struct_();
+    literal_type_.struct__ = struct_;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.struct)
+}
+inline ::substrait::Expression_Literal_Struct* Expression_Literal::_internal_mutable_struct_() {
+  if (!_internal_has_struct_()) {
+    clear_literal_type();
+    set_has_struct_();
+    literal_type_.struct__ = CreateMaybeMessage< ::substrait::Expression_Literal_Struct >(GetArenaForAllocation());
+  }
+  return literal_type_.struct__;
+}
+inline ::substrait::Expression_Literal_Struct* Expression_Literal::mutable_struct_() {
+  ::substrait::Expression_Literal_Struct* _msg = _internal_mutable_struct_();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.struct)
+  return _msg;
+}
+
+// .substrait.Expression.Literal.Map map = 26;
+inline bool Expression_Literal::_internal_has_map() const {
+  return literal_type_case() == kMap;
+}
+inline bool Expression_Literal::has_map() const {
+  return _internal_has_map();
+}
+inline void Expression_Literal::set_has_map() {
+  _oneof_case_[0] = kMap;
+}
+inline void Expression_Literal::clear_map() {
+  if (_internal_has_map()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete literal_type_.map_;
+    }
+    clear_has_literal_type();
+  }
+}
+inline ::substrait::Expression_Literal_Map* Expression_Literal::release_map() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.map)
+  if (_internal_has_map()) {
+    clear_has_literal_type();
+      ::substrait::Expression_Literal_Map* temp = literal_type_.map_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    literal_type_.map_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_Literal_Map& Expression_Literal::_internal_map() const {
+  return _internal_has_map()
+      ? *literal_type_.map_
+      : reinterpret_cast< ::substrait::Expression_Literal_Map&>(::substrait::_Expression_Literal_Map_default_instance_);
+}
+inline const ::substrait::Expression_Literal_Map& Expression_Literal::map() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.map)
+  return _internal_map();
+}
+inline ::substrait::Expression_Literal_Map* Expression_Literal::unsafe_arena_release_map() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.map)
+  if (_internal_has_map()) {
+    clear_has_literal_type();
+    ::substrait::Expression_Literal_Map* temp = literal_type_.map_;
+    literal_type_.map_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::unsafe_arena_set_allocated_map(::substrait::Expression_Literal_Map* map) {
+  clear_literal_type();
+  if (map) {
+    set_has_map();
+    literal_type_.map_ = map;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.map)
+}
+inline ::substrait::Expression_Literal_Map* Expression_Literal::_internal_mutable_map() {
+  if (!_internal_has_map()) {
+    clear_literal_type();
+    set_has_map();
+    literal_type_.map_ = CreateMaybeMessage< ::substrait::Expression_Literal_Map >(GetArenaForAllocation());
+  }
+  return literal_type_.map_;
+}
+inline ::substrait::Expression_Literal_Map* Expression_Literal::mutable_map() {
+  ::substrait::Expression_Literal_Map* _msg = _internal_mutable_map();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.map)
+  return _msg;
+}
+
+// int64 timestamp_tz = 27;
+inline bool Expression_Literal::_internal_has_timestamp_tz() const {
+  return literal_type_case() == kTimestampTz;
+}
+inline bool Expression_Literal::has_timestamp_tz() const {
+  return _internal_has_timestamp_tz();
+}
+inline void Expression_Literal::set_has_timestamp_tz() {
+  _oneof_case_[0] = kTimestampTz;
+}
+inline void Expression_Literal::clear_timestamp_tz() {
+  if (_internal_has_timestamp_tz()) {
+    literal_type_.timestamp_tz_ = int64_t{0};
+    clear_has_literal_type();
+  }
+}
+inline int64_t Expression_Literal::_internal_timestamp_tz() const {
+  if (_internal_has_timestamp_tz()) {
+    return literal_type_.timestamp_tz_;
+  }
+  return int64_t{0};
+}
+inline void Expression_Literal::_internal_set_timestamp_tz(int64_t value) {
+  if (!_internal_has_timestamp_tz()) {
+    clear_literal_type();
+    set_has_timestamp_tz();
+  }
+  literal_type_.timestamp_tz_ = value;
+}
+inline int64_t Expression_Literal::timestamp_tz() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.timestamp_tz)
+  return _internal_timestamp_tz();
+}
+inline void Expression_Literal::set_timestamp_tz(int64_t value) {
+  _internal_set_timestamp_tz(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.timestamp_tz)
+}
+
+// bytes uuid = 28;
+inline bool Expression_Literal::_internal_has_uuid() const {
+  return literal_type_case() == kUuid;
+}
+inline bool Expression_Literal::has_uuid() const {
+  return _internal_has_uuid();
+}
+inline void Expression_Literal::set_has_uuid() {
+  _oneof_case_[0] = kUuid;
+}
+inline void Expression_Literal::clear_uuid() {
+  if (_internal_has_uuid()) {
+    literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_literal_type();
+  }
+}
+inline const std::string& Expression_Literal::uuid() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.uuid)
+  return _internal_uuid();
+}
+template <typename ArgT0, typename... ArgT>
+inline void Expression_Literal::set_uuid(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_uuid()) {
+    clear_literal_type();
+    set_has_uuid();
+    literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  literal_type_.uuid_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.uuid)
+}
+inline std::string* Expression_Literal::mutable_uuid() {
+  std::string* _s = _internal_mutable_uuid();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.uuid)
+  return _s;
+}
+inline const std::string& Expression_Literal::_internal_uuid() const {
+  if (_internal_has_uuid()) {
+    return literal_type_.uuid_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void Expression_Literal::_internal_set_uuid(const std::string& value) {
+  if (!_internal_has_uuid()) {
+    clear_literal_type();
+    set_has_uuid();
+    literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  literal_type_.uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal::_internal_mutable_uuid() {
+  if (!_internal_has_uuid()) {
+    clear_literal_type();
+    set_has_uuid();
+    literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return literal_type_.uuid_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Expression_Literal::release_uuid() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.uuid)
+  if (_internal_has_uuid()) {
+    clear_has_literal_type();
+    return literal_type_.uuid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::set_allocated_uuid(std::string* uuid) {
+  if (has_literal_type()) {
+    clear_literal_type();
+  }
+  if (uuid != nullptr) {
+    set_has_uuid();
+    literal_type_.uuid_.UnsafeSetDefault(uuid);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(uuid);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.uuid)
+}
+
+// .substrait.Type null = 29;
+inline bool Expression_Literal::_internal_has_null() const {
+  return literal_type_case() == kNull;
+}
+inline bool Expression_Literal::has_null() const {
+  return _internal_has_null();
+}
+inline void Expression_Literal::set_has_null() {
+  _oneof_case_[0] = kNull;
+}
+inline ::substrait::Type* Expression_Literal::release_null() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.null)
+  if (_internal_has_null()) {
+    clear_has_literal_type();
+      ::substrait::Type* temp = literal_type_.null_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    literal_type_.null_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type& Expression_Literal::_internal_null() const {
+  return _internal_has_null()
+      ? *literal_type_.null_
+      : reinterpret_cast< ::substrait::Type&>(::substrait::_Type_default_instance_);
+}
+inline const ::substrait::Type& Expression_Literal::null() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.null)
+  return _internal_null();
+}
+inline ::substrait::Type* Expression_Literal::unsafe_arena_release_null() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.null)
+  if (_internal_has_null()) {
+    clear_has_literal_type();
+    ::substrait::Type* temp = literal_type_.null_;
+    literal_type_.null_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::unsafe_arena_set_allocated_null(::substrait::Type* null) {
+  clear_literal_type();
+  if (null) {
+    set_has_null();
+    literal_type_.null_ = null;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.null)
+}
+inline ::substrait::Type* Expression_Literal::_internal_mutable_null() {
+  if (!_internal_has_null()) {
+    clear_literal_type();
+    set_has_null();
+    literal_type_.null_ = CreateMaybeMessage< ::substrait::Type >(GetArenaForAllocation());
+  }
+  return literal_type_.null_;
+}
+inline ::substrait::Type* Expression_Literal::mutable_null() {
+  ::substrait::Type* _msg = _internal_mutable_null();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.null)
+  return _msg;
+}
+
+// .substrait.Expression.Literal.List list = 30;
+inline bool Expression_Literal::_internal_has_list() const {
+  return literal_type_case() == kList;
+}
+inline bool Expression_Literal::has_list() const {
+  return _internal_has_list();
+}
+inline void Expression_Literal::set_has_list() {
+  _oneof_case_[0] = kList;
+}
+inline void Expression_Literal::clear_list() {
+  if (_internal_has_list()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete literal_type_.list_;
+    }
+    clear_has_literal_type();
+  }
+}
+inline ::substrait::Expression_Literal_List* Expression_Literal::release_list() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.list)
+  if (_internal_has_list()) {
+    clear_has_literal_type();
+      ::substrait::Expression_Literal_List* temp = literal_type_.list_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    literal_type_.list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_Literal_List& Expression_Literal::_internal_list() const {
+  return _internal_has_list()
+      ? *literal_type_.list_
+      : reinterpret_cast< ::substrait::Expression_Literal_List&>(::substrait::_Expression_Literal_List_default_instance_);
+}
+inline const ::substrait::Expression_Literal_List& Expression_Literal::list() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.list)
+  return _internal_list();
+}
+inline ::substrait::Expression_Literal_List* Expression_Literal::unsafe_arena_release_list() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.list)
+  if (_internal_has_list()) {
+    clear_has_literal_type();
+    ::substrait::Expression_Literal_List* temp = literal_type_.list_;
+    literal_type_.list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::unsafe_arena_set_allocated_list(::substrait::Expression_Literal_List* list) {
+  clear_literal_type();
+  if (list) {
+    set_has_list();
+    literal_type_.list_ = list;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.list)
+}
+inline ::substrait::Expression_Literal_List* Expression_Literal::_internal_mutable_list() {
+  if (!_internal_has_list()) {
+    clear_literal_type();
+    set_has_list();
+    literal_type_.list_ = CreateMaybeMessage< ::substrait::Expression_Literal_List >(GetArenaForAllocation());
+  }
+  return literal_type_.list_;
+}
+inline ::substrait::Expression_Literal_List* Expression_Literal::mutable_list() {
+  ::substrait::Expression_Literal_List* _msg = _internal_mutable_list();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.list)
+  return _msg;
+}
+
+// .substrait.Type.List empty_list = 31;
+inline bool Expression_Literal::_internal_has_empty_list() const {
+  return literal_type_case() == kEmptyList;
+}
+inline bool Expression_Literal::has_empty_list() const {
+  return _internal_has_empty_list();
+}
+inline void Expression_Literal::set_has_empty_list() {
+  _oneof_case_[0] = kEmptyList;
+}
+inline ::substrait::Type_List* Expression_Literal::release_empty_list() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.empty_list)
+  if (_internal_has_empty_list()) {
+    clear_has_literal_type();
+      ::substrait::Type_List* temp = literal_type_.empty_list_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    literal_type_.empty_list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_List& Expression_Literal::_internal_empty_list() const {
+  return _internal_has_empty_list()
+      ? *literal_type_.empty_list_
+      : reinterpret_cast< ::substrait::Type_List&>(::substrait::_Type_List_default_instance_);
+}
+inline const ::substrait::Type_List& Expression_Literal::empty_list() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.empty_list)
+  return _internal_empty_list();
+}
+inline ::substrait::Type_List* Expression_Literal::unsafe_arena_release_empty_list() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.empty_list)
+  if (_internal_has_empty_list()) {
+    clear_has_literal_type();
+    ::substrait::Type_List* temp = literal_type_.empty_list_;
+    literal_type_.empty_list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::unsafe_arena_set_allocated_empty_list(::substrait::Type_List* empty_list) {
+  clear_literal_type();
+  if (empty_list) {
+    set_has_empty_list();
+    literal_type_.empty_list_ = empty_list;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.empty_list)
+}
+inline ::substrait::Type_List* Expression_Literal::_internal_mutable_empty_list() {
+  if (!_internal_has_empty_list()) {
+    clear_literal_type();
+    set_has_empty_list();
+    literal_type_.empty_list_ = CreateMaybeMessage< ::substrait::Type_List >(GetArenaForAllocation());
+  }
+  return literal_type_.empty_list_;
+}
+inline ::substrait::Type_List* Expression_Literal::mutable_empty_list() {
+  ::substrait::Type_List* _msg = _internal_mutable_empty_list();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.empty_list)
+  return _msg;
+}
+
+// .substrait.Type.Map empty_map = 32;
+inline bool Expression_Literal::_internal_has_empty_map() const {
+  return literal_type_case() == kEmptyMap;
+}
+inline bool Expression_Literal::has_empty_map() const {
+  return _internal_has_empty_map();
+}
+inline void Expression_Literal::set_has_empty_map() {
+  _oneof_case_[0] = kEmptyMap;
+}
+inline ::substrait::Type_Map* Expression_Literal::release_empty_map() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Literal.empty_map)
+  if (_internal_has_empty_map()) {
+    clear_has_literal_type();
+      ::substrait::Type_Map* temp = literal_type_.empty_map_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    literal_type_.empty_map_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Map& Expression_Literal::_internal_empty_map() const {
+  return _internal_has_empty_map()
+      ? *literal_type_.empty_map_
+      : reinterpret_cast< ::substrait::Type_Map&>(::substrait::_Type_Map_default_instance_);
+}
+inline const ::substrait::Type_Map& Expression_Literal::empty_map() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.empty_map)
+  return _internal_empty_map();
+}
+inline ::substrait::Type_Map* Expression_Literal::unsafe_arena_release_empty_map() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.empty_map)
+  if (_internal_has_empty_map()) {
+    clear_has_literal_type();
+    ::substrait::Type_Map* temp = literal_type_.empty_map_;
+    literal_type_.empty_map_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_Literal::unsafe_arena_set_allocated_empty_map(::substrait::Type_Map* empty_map) {
+  clear_literal_type();
+  if (empty_map) {
+    set_has_empty_map();
+    literal_type_.empty_map_ = empty_map;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.empty_map)
+}
+inline ::substrait::Type_Map* Expression_Literal::_internal_mutable_empty_map() {
+  if (!_internal_has_empty_map()) {
+    clear_literal_type();
+    set_has_empty_map();
+    literal_type_.empty_map_ = CreateMaybeMessage< ::substrait::Type_Map >(GetArenaForAllocation());
+  }
+  return literal_type_.empty_map_;
+}
+inline ::substrait::Type_Map* Expression_Literal::mutable_empty_map() {
+  ::substrait::Type_Map* _msg = _internal_mutable_empty_map();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.empty_map)
+  return _msg;
+}
+
+// bool nullable = 50;
+inline void Expression_Literal::clear_nullable() {
+  nullable_ = false;
+}
+inline bool Expression_Literal::_internal_nullable() const {
+  return nullable_;
+}
+inline bool Expression_Literal::nullable() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Literal.nullable)
+  return _internal_nullable();
+}
+inline void Expression_Literal::_internal_set_nullable(bool value) {
+  
+  nullable_ = value;
+}
+inline void Expression_Literal::set_nullable(bool value) {
+  _internal_set_nullable(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.Literal.nullable)
+}
+
+inline bool Expression_Literal::has_literal_type() const {
+  return literal_type_case() != LITERAL_TYPE_NOT_SET;
+}
+inline void Expression_Literal::clear_has_literal_type() {
+  _oneof_case_[0] = LITERAL_TYPE_NOT_SET;
+}
+inline Expression_Literal::LiteralTypeCase Expression_Literal::literal_type_case() const {
+  return Expression_Literal::LiteralTypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Expression_ScalarFunction
+
+// uint32 function_reference = 1;
+inline void Expression_ScalarFunction::clear_function_reference() {
+  function_reference_ = 0u;
+}
+inline uint32_t Expression_ScalarFunction::_internal_function_reference() const {
+  return function_reference_;
+}
+inline uint32_t Expression_ScalarFunction::function_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.ScalarFunction.function_reference)
+  return _internal_function_reference();
+}
+inline void Expression_ScalarFunction::_internal_set_function_reference(uint32_t value) {
+  
+  function_reference_ = value;
+}
+inline void Expression_ScalarFunction::set_function_reference(uint32_t value) {
+  _internal_set_function_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.ScalarFunction.function_reference)
+}
+
+// repeated .substrait.Expression args = 2;
+inline int Expression_ScalarFunction::_internal_args_size() const {
+  return args_.size();
+}
+inline int Expression_ScalarFunction::args_size() const {
+  return _internal_args_size();
+}
+inline void Expression_ScalarFunction::clear_args() {
+  args_.Clear();
+}
+inline ::substrait::Expression* Expression_ScalarFunction::mutable_args(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.ScalarFunction.args)
+  return args_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+Expression_ScalarFunction::mutable_args() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.ScalarFunction.args)
+  return &args_;
+}
+inline const ::substrait::Expression& Expression_ScalarFunction::_internal_args(int index) const {
+  return args_.Get(index);
+}
+inline const ::substrait::Expression& Expression_ScalarFunction::args(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.ScalarFunction.args)
+  return _internal_args(index);
+}
+inline ::substrait::Expression* Expression_ScalarFunction::_internal_add_args() {
+  return args_.Add();
+}
+inline ::substrait::Expression* Expression_ScalarFunction::add_args() {
+  ::substrait::Expression* _add = _internal_add_args();
+  // @@protoc_insertion_point(field_add:substrait.Expression.ScalarFunction.args)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+Expression_ScalarFunction::args() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.ScalarFunction.args)
+  return args_;
+}
+
+// .substrait.Type output_type = 3;
+inline bool Expression_ScalarFunction::_internal_has_output_type() const {
+  return this != internal_default_instance() && output_type_ != nullptr;
+}
+inline bool Expression_ScalarFunction::has_output_type() const {
+  return _internal_has_output_type();
+}
+inline const ::substrait::Type& Expression_ScalarFunction::_internal_output_type() const {
+  const ::substrait::Type* p = output_type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Type&>(
+      ::substrait::_Type_default_instance_);
+}
+inline const ::substrait::Type& Expression_ScalarFunction::output_type() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.ScalarFunction.output_type)
+  return _internal_output_type();
+}
+inline void Expression_ScalarFunction::unsafe_arena_set_allocated_output_type(
+    ::substrait::Type* output_type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  output_type_ = output_type;
+  if (output_type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ScalarFunction.output_type)
+}
+inline ::substrait::Type* Expression_ScalarFunction::release_output_type() {
+  
+  ::substrait::Type* temp = output_type_;
+  output_type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Type* Expression_ScalarFunction::unsafe_arena_release_output_type() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.ScalarFunction.output_type)
+  
+  ::substrait::Type* temp = output_type_;
+  output_type_ = nullptr;
+  return temp;
+}
+inline ::substrait::Type* Expression_ScalarFunction::_internal_mutable_output_type() {
+  
+  if (output_type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation());
+    output_type_ = p;
+  }
+  return output_type_;
+}
+inline ::substrait::Type* Expression_ScalarFunction::mutable_output_type() {
+  ::substrait::Type* _msg = _internal_mutable_output_type();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.ScalarFunction.output_type)
+  return _msg;
+}
+inline void Expression_ScalarFunction::set_allocated_output_type(::substrait::Type* output_type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  if (output_type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type));
+    if (message_arena != submessage_arena) {
+      output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, output_type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  output_type_ = output_type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ScalarFunction.output_type)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_WindowFunction_Bound_Preceding
+
+// int64 offset = 1;
+inline void Expression_WindowFunction_Bound_Preceding::clear_offset() {
+  offset_ = int64_t{0};
+}
+inline int64_t Expression_WindowFunction_Bound_Preceding::_internal_offset() const {
+  return offset_;
+}
+inline int64_t Expression_WindowFunction_Bound_Preceding::offset() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.Preceding.offset)
+  return _internal_offset();
+}
+inline void Expression_WindowFunction_Bound_Preceding::_internal_set_offset(int64_t value) {
+  
+  offset_ = value;
+}
+inline void Expression_WindowFunction_Bound_Preceding::set_offset(int64_t value) {
+  _internal_set_offset(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.Bound.Preceding.offset)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_WindowFunction_Bound_Following
+
+// int64 offset = 1;
+inline void Expression_WindowFunction_Bound_Following::clear_offset() {
+  offset_ = int64_t{0};
+}
+inline int64_t Expression_WindowFunction_Bound_Following::_internal_offset() const {
+  return offset_;
+}
+inline int64_t Expression_WindowFunction_Bound_Following::offset() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.Following.offset)
+  return _internal_offset();
+}
+inline void Expression_WindowFunction_Bound_Following::_internal_set_offset(int64_t value) {
+  
+  offset_ = value;
+}
+inline void Expression_WindowFunction_Bound_Following::set_offset(int64_t value) {
+  _internal_set_offset(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.Bound.Following.offset)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_WindowFunction_Bound_CurrentRow
+
+// -------------------------------------------------------------------
+
+// Expression_WindowFunction_Bound_Unbounded
+
+// -------------------------------------------------------------------
+
+// Expression_WindowFunction_Bound
+
+// .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1;
+inline bool Expression_WindowFunction_Bound::_internal_has_preceding() const {
+  return kind_case() == kPreceding;
+}
+inline bool Expression_WindowFunction_Bound::has_preceding() const {
+  return _internal_has_preceding();
+}
+inline void Expression_WindowFunction_Bound::set_has_preceding() {
+  _oneof_case_[0] = kPreceding;
+}
+inline void Expression_WindowFunction_Bound::clear_preceding() {
+  if (_internal_has_preceding()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.preceding_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::release_preceding() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.Bound.preceding)
+  if (_internal_has_preceding()) {
+    clear_has_kind();
+      ::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.preceding_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::_internal_preceding() const {
+  return _internal_has_preceding()
+      ? *kind_.preceding_
+      : reinterpret_cast< ::substrait::Expression_WindowFunction_Bound_Preceding&>(::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_);
+}
+inline const ::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::preceding() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.preceding)
+  return _internal_preceding();
+}
+inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::unsafe_arena_release_preceding() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.WindowFunction.Bound.preceding)
+  if (_internal_has_preceding()) {
+    clear_has_kind();
+    ::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_;
+    kind_.preceding_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_preceding(::substrait::Expression_WindowFunction_Bound_Preceding* preceding) {
+  clear_kind();
+  if (preceding) {
+    set_has_preceding();
+    kind_.preceding_ = preceding;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.Bound.preceding)
+}
+inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::_internal_mutable_preceding() {
+  if (!_internal_has_preceding()) {
+    clear_kind();
+    set_has_preceding();
+    kind_.preceding_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Preceding >(GetArenaForAllocation());
+  }
+  return kind_.preceding_;
+}
+inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::mutable_preceding() {
+  ::substrait::Expression_WindowFunction_Bound_Preceding* _msg = _internal_mutable_preceding();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.preceding)
+  return _msg;
+}
+
+// .substrait.Expression.WindowFunction.Bound.Following following = 2;
+inline bool Expression_WindowFunction_Bound::_internal_has_following() const {
+  return kind_case() == kFollowing;
+}
+inline bool Expression_WindowFunction_Bound::has_following() const {
+  return _internal_has_following();
+}
+inline void Expression_WindowFunction_Bound::set_has_following() {
+  _oneof_case_[0] = kFollowing;
+}
+inline void Expression_WindowFunction_Bound::clear_following() {
+  if (_internal_has_following()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.following_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::release_following() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.Bound.following)
+  if (_internal_has_following()) {
+    clear_has_kind();
+      ::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.following_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::_internal_following() const {
+  return _internal_has_following()
+      ? *kind_.following_
+      : reinterpret_cast< ::substrait::Expression_WindowFunction_Bound_Following&>(::substrait::_Expression_WindowFunction_Bound_Following_default_instance_);
+}
+inline const ::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::following() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.following)
+  return _internal_following();
+}
+inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::unsafe_arena_release_following() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.WindowFunction.Bound.following)
+  if (_internal_has_following()) {
+    clear_has_kind();
+    ::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_;
+    kind_.following_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_following(::substrait::Expression_WindowFunction_Bound_Following* following) {
+  clear_kind();
+  if (following) {
+    set_has_following();
+    kind_.following_ = following;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.Bound.following)
+}
+inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::_internal_mutable_following() {
+  if (!_internal_has_following()) {
+    clear_kind();
+    set_has_following();
+    kind_.following_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Following >(GetArenaForAllocation());
+  }
+  return kind_.following_;
+}
+inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::mutable_following() {
+  ::substrait::Expression_WindowFunction_Bound_Following* _msg = _internal_mutable_following();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.following)
+  return _msg;
+}
+
+// .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3;
+inline bool Expression_WindowFunction_Bound::_internal_has_current_row() const {
+  return kind_case() == kCurrentRow;
+}
+inline bool Expression_WindowFunction_Bound::has_current_row() const {
+  return _internal_has_current_row();
+}
+inline void Expression_WindowFunction_Bound::set_has_current_row() {
+  _oneof_case_[0] = kCurrentRow;
+}
+inline void Expression_WindowFunction_Bound::clear_current_row() {
+  if (_internal_has_current_row()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.current_row_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::release_current_row() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.Bound.current_row)
+  if (_internal_has_current_row()) {
+    clear_has_kind();
+      ::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.current_row_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::_internal_current_row() const {
+  return _internal_has_current_row()
+      ? *kind_.current_row_
+      : reinterpret_cast< ::substrait::Expression_WindowFunction_Bound_CurrentRow&>(::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_);
+}
+inline const ::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::current_row() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.current_row)
+  return _internal_current_row();
+}
+inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::unsafe_arena_release_current_row() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.WindowFunction.Bound.current_row)
+  if (_internal_has_current_row()) {
+    clear_has_kind();
+    ::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_;
+    kind_.current_row_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_current_row(::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) {
+  clear_kind();
+  if (current_row) {
+    set_has_current_row();
+    kind_.current_row_ = current_row;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.Bound.current_row)
+}
+inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::_internal_mutable_current_row() {
+  if (!_internal_has_current_row()) {
+    clear_kind();
+    set_has_current_row();
+    kind_.current_row_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(GetArenaForAllocation());
+  }
+  return kind_.current_row_;
+}
+inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::mutable_current_row() {
+  ::substrait::Expression_WindowFunction_Bound_CurrentRow* _msg = _internal_mutable_current_row();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.current_row)
+  return _msg;
+}
+
+// .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4;
+inline bool Expression_WindowFunction_Bound::_internal_has_unbounded() const {
+  return kind_case() == kUnbounded;
+}
+inline bool Expression_WindowFunction_Bound::has_unbounded() const {
+  return _internal_has_unbounded();
+}
+inline void Expression_WindowFunction_Bound::set_has_unbounded() {
+  _oneof_case_[0] = kUnbounded;
+}
+inline void Expression_WindowFunction_Bound::clear_unbounded() {
+  if (_internal_has_unbounded()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.unbounded_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::release_unbounded() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.Bound.unbounded)
+  if (_internal_has_unbounded()) {
+    clear_has_kind();
+      ::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.unbounded_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::_internal_unbounded() const {
+  return _internal_has_unbounded()
+      ? *kind_.unbounded_
+      : reinterpret_cast< ::substrait::Expression_WindowFunction_Bound_Unbounded&>(::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_);
+}
+inline const ::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::unbounded() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.unbounded)
+  return _internal_unbounded();
+}
+inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::unsafe_arena_release_unbounded() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.WindowFunction.Bound.unbounded)
+  if (_internal_has_unbounded()) {
+    clear_has_kind();
+    ::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_;
+    kind_.unbounded_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_unbounded(::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) {
+  clear_kind();
+  if (unbounded) {
+    set_has_unbounded();
+    kind_.unbounded_ = unbounded;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.Bound.unbounded)
+}
+inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::_internal_mutable_unbounded() {
+  if (!_internal_has_unbounded()) {
+    clear_kind();
+    set_has_unbounded();
+    kind_.unbounded_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Unbounded >(GetArenaForAllocation());
+  }
+  return kind_.unbounded_;
+}
+inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::mutable_unbounded() {
+  ::substrait::Expression_WindowFunction_Bound_Unbounded* _msg = _internal_mutable_unbounded();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.unbounded)
+  return _msg;
+}
+
+inline bool Expression_WindowFunction_Bound::has_kind() const {
+  return kind_case() != KIND_NOT_SET;
+}
+inline void Expression_WindowFunction_Bound::clear_has_kind() {
+  _oneof_case_[0] = KIND_NOT_SET;
+}
+inline Expression_WindowFunction_Bound::KindCase Expression_WindowFunction_Bound::kind_case() const {
+  return Expression_WindowFunction_Bound::KindCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Expression_WindowFunction
+
+// uint32 function_reference = 1;
+inline void Expression_WindowFunction::clear_function_reference() {
+  function_reference_ = 0u;
+}
+inline uint32_t Expression_WindowFunction::_internal_function_reference() const {
+  return function_reference_;
+}
+inline uint32_t Expression_WindowFunction::function_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.function_reference)
+  return _internal_function_reference();
+}
+inline void Expression_WindowFunction::_internal_set_function_reference(uint32_t value) {
+  
+  function_reference_ = value;
+}
+inline void Expression_WindowFunction::set_function_reference(uint32_t value) {
+  _internal_set_function_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.function_reference)
+}
+
+// repeated .substrait.Expression partitions = 2;
+inline int Expression_WindowFunction::_internal_partitions_size() const {
+  return partitions_.size();
+}
+inline int Expression_WindowFunction::partitions_size() const {
+  return _internal_partitions_size();
+}
+inline void Expression_WindowFunction::clear_partitions() {
+  partitions_.Clear();
+}
+inline ::substrait::Expression* Expression_WindowFunction::mutable_partitions(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.partitions)
+  return partitions_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+Expression_WindowFunction::mutable_partitions() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.WindowFunction.partitions)
+  return &partitions_;
+}
+inline const ::substrait::Expression& Expression_WindowFunction::_internal_partitions(int index) const {
+  return partitions_.Get(index);
+}
+inline const ::substrait::Expression& Expression_WindowFunction::partitions(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.partitions)
+  return _internal_partitions(index);
+}
+inline ::substrait::Expression* Expression_WindowFunction::_internal_add_partitions() {
+  return partitions_.Add();
+}
+inline ::substrait::Expression* Expression_WindowFunction::add_partitions() {
+  ::substrait::Expression* _add = _internal_add_partitions();
+  // @@protoc_insertion_point(field_add:substrait.Expression.WindowFunction.partitions)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+Expression_WindowFunction::partitions() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.WindowFunction.partitions)
+  return partitions_;
+}
+
+// repeated .substrait.SortField sorts = 3;
+inline int Expression_WindowFunction::_internal_sorts_size() const {
+  return sorts_.size();
+}
+inline int Expression_WindowFunction::sorts_size() const {
+  return _internal_sorts_size();
+}
+inline void Expression_WindowFunction::clear_sorts() {
+  sorts_.Clear();
+}
+inline ::substrait::SortField* Expression_WindowFunction::mutable_sorts(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.sorts)
+  return sorts_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >*
+Expression_WindowFunction::mutable_sorts() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.WindowFunction.sorts)
+  return &sorts_;
+}
+inline const ::substrait::SortField& Expression_WindowFunction::_internal_sorts(int index) const {
+  return sorts_.Get(index);
+}
+inline const ::substrait::SortField& Expression_WindowFunction::sorts(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.sorts)
+  return _internal_sorts(index);
+}
+inline ::substrait::SortField* Expression_WindowFunction::_internal_add_sorts() {
+  return sorts_.Add();
+}
+inline ::substrait::SortField* Expression_WindowFunction::add_sorts() {
+  ::substrait::SortField* _add = _internal_add_sorts();
+  // @@protoc_insertion_point(field_add:substrait.Expression.WindowFunction.sorts)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >&
+Expression_WindowFunction::sorts() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.WindowFunction.sorts)
+  return sorts_;
+}
+
+// .substrait.Expression.WindowFunction.Bound upper_bound = 4;
+inline bool Expression_WindowFunction::_internal_has_upper_bound() const {
+  return this != internal_default_instance() && upper_bound_ != nullptr;
+}
+inline bool Expression_WindowFunction::has_upper_bound() const {
+  return _internal_has_upper_bound();
+}
+inline void Expression_WindowFunction::clear_upper_bound() {
+  if (GetArenaForAllocation() == nullptr && upper_bound_ != nullptr) {
+    delete upper_bound_;
+  }
+  upper_bound_ = nullptr;
+}
+inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_upper_bound() const {
+  const ::substrait::Expression_WindowFunction_Bound* p = upper_bound_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_WindowFunction_Bound&>(
+      ::substrait::_Expression_WindowFunction_Bound_default_instance_);
+}
+inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::upper_bound() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.upper_bound)
+  return _internal_upper_bound();
+}
+inline void Expression_WindowFunction::unsafe_arena_set_allocated_upper_bound(
+    ::substrait::Expression_WindowFunction_Bound* upper_bound) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(upper_bound_);
+  }
+  upper_bound_ = upper_bound;
+  if (upper_bound) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.upper_bound)
+}
+inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_upper_bound() {
+  
+  ::substrait::Expression_WindowFunction_Bound* temp = upper_bound_;
+  upper_bound_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_upper_bound() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.upper_bound)
+  
+  ::substrait::Expression_WindowFunction_Bound* temp = upper_bound_;
+  upper_bound_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_upper_bound() {
+  
+  if (upper_bound_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(GetArenaForAllocation());
+    upper_bound_ = p;
+  }
+  return upper_bound_;
+}
+inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_upper_bound() {
+  ::substrait::Expression_WindowFunction_Bound* _msg = _internal_mutable_upper_bound();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.upper_bound)
+  return _msg;
+}
+inline void Expression_WindowFunction::set_allocated_upper_bound(::substrait::Expression_WindowFunction_Bound* upper_bound) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete upper_bound_;
+  }
+  if (upper_bound) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound>::GetOwningArena(upper_bound);
+    if (message_arena != submessage_arena) {
+      upper_bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, upper_bound, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  upper_bound_ = upper_bound;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.upper_bound)
+}
+
+// .substrait.Expression.WindowFunction.Bound lower_bound = 5;
+inline bool Expression_WindowFunction::_internal_has_lower_bound() const {
+  return this != internal_default_instance() && lower_bound_ != nullptr;
+}
+inline bool Expression_WindowFunction::has_lower_bound() const {
+  return _internal_has_lower_bound();
+}
+inline void Expression_WindowFunction::clear_lower_bound() {
+  if (GetArenaForAllocation() == nullptr && lower_bound_ != nullptr) {
+    delete lower_bound_;
+  }
+  lower_bound_ = nullptr;
+}
+inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_lower_bound() const {
+  const ::substrait::Expression_WindowFunction_Bound* p = lower_bound_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_WindowFunction_Bound&>(
+      ::substrait::_Expression_WindowFunction_Bound_default_instance_);
+}
+inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::lower_bound() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.lower_bound)
+  return _internal_lower_bound();
+}
+inline void Expression_WindowFunction::unsafe_arena_set_allocated_lower_bound(
+    ::substrait::Expression_WindowFunction_Bound* lower_bound) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lower_bound_);
+  }
+  lower_bound_ = lower_bound;
+  if (lower_bound) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.lower_bound)
+}
+inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_lower_bound() {
+  
+  ::substrait::Expression_WindowFunction_Bound* temp = lower_bound_;
+  lower_bound_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_lower_bound() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.lower_bound)
+  
+  ::substrait::Expression_WindowFunction_Bound* temp = lower_bound_;
+  lower_bound_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_lower_bound() {
+  
+  if (lower_bound_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(GetArenaForAllocation());
+    lower_bound_ = p;
+  }
+  return lower_bound_;
+}
+inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_lower_bound() {
+  ::substrait::Expression_WindowFunction_Bound* _msg = _internal_mutable_lower_bound();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.lower_bound)
+  return _msg;
+}
+inline void Expression_WindowFunction::set_allocated_lower_bound(::substrait::Expression_WindowFunction_Bound* lower_bound) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete lower_bound_;
+  }
+  if (lower_bound) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound>::GetOwningArena(lower_bound);
+    if (message_arena != submessage_arena) {
+      lower_bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, lower_bound, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  lower_bound_ = lower_bound;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.lower_bound)
+}
+
+// .substrait.AggregationPhase phase = 6;
+inline void Expression_WindowFunction::clear_phase() {
+  phase_ = 0;
+}
+inline ::substrait::AggregationPhase Expression_WindowFunction::_internal_phase() const {
+  return static_cast< ::substrait::AggregationPhase >(phase_);
+}
+inline ::substrait::AggregationPhase Expression_WindowFunction::phase() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.phase)
+  return _internal_phase();
+}
+inline void Expression_WindowFunction::_internal_set_phase(::substrait::AggregationPhase value) {
+  
+  phase_ = value;
+}
+inline void Expression_WindowFunction::set_phase(::substrait::AggregationPhase value) {
+  _internal_set_phase(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.phase)
+}
+
+// .substrait.Type output_type = 7;
+inline bool Expression_WindowFunction::_internal_has_output_type() const {
+  return this != internal_default_instance() && output_type_ != nullptr;
+}
+inline bool Expression_WindowFunction::has_output_type() const {
+  return _internal_has_output_type();
+}
+inline const ::substrait::Type& Expression_WindowFunction::_internal_output_type() const {
+  const ::substrait::Type* p = output_type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Type&>(
+      ::substrait::_Type_default_instance_);
+}
+inline const ::substrait::Type& Expression_WindowFunction::output_type() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.output_type)
+  return _internal_output_type();
+}
+inline void Expression_WindowFunction::unsafe_arena_set_allocated_output_type(
+    ::substrait::Type* output_type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  output_type_ = output_type;
+  if (output_type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.output_type)
+}
+inline ::substrait::Type* Expression_WindowFunction::release_output_type() {
+  
+  ::substrait::Type* temp = output_type_;
+  output_type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Type* Expression_WindowFunction::unsafe_arena_release_output_type() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.output_type)
+  
+  ::substrait::Type* temp = output_type_;
+  output_type_ = nullptr;
+  return temp;
+}
+inline ::substrait::Type* Expression_WindowFunction::_internal_mutable_output_type() {
+  
+  if (output_type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation());
+    output_type_ = p;
+  }
+  return output_type_;
+}
+inline ::substrait::Type* Expression_WindowFunction::mutable_output_type() {
+  ::substrait::Type* _msg = _internal_mutable_output_type();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.output_type)
+  return _msg;
+}
+inline void Expression_WindowFunction::set_allocated_output_type(::substrait::Type* output_type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  if (output_type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type));
+    if (message_arena != submessage_arena) {
+      output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, output_type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  output_type_ = output_type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.output_type)
+}
+
+// repeated .substrait.Expression args = 8;
+inline int Expression_WindowFunction::_internal_args_size() const {
+  return args_.size();
+}
+inline int Expression_WindowFunction::args_size() const {
+  return _internal_args_size();
+}
+inline void Expression_WindowFunction::clear_args() {
+  args_.Clear();
+}
+inline ::substrait::Expression* Expression_WindowFunction::mutable_args(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.args)
+  return args_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+Expression_WindowFunction::mutable_args() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.WindowFunction.args)
+  return &args_;
+}
+inline const ::substrait::Expression& Expression_WindowFunction::_internal_args(int index) const {
+  return args_.Get(index);
+}
+inline const ::substrait::Expression& Expression_WindowFunction::args(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.args)
+  return _internal_args(index);
+}
+inline ::substrait::Expression* Expression_WindowFunction::_internal_add_args() {
+  return args_.Add();
+}
+inline ::substrait::Expression* Expression_WindowFunction::add_args() {
+  ::substrait::Expression* _add = _internal_add_args();
+  // @@protoc_insertion_point(field_add:substrait.Expression.WindowFunction.args)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+Expression_WindowFunction::args() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.WindowFunction.args)
+  return args_;
+}
+
+// -------------------------------------------------------------------
+
+// Expression_IfThen_IfClause
+
+// .substrait.Expression if = 1;
+inline bool Expression_IfThen_IfClause::_internal_has_if_() const {
+  return this != internal_default_instance() && if__ != nullptr;
+}
+inline bool Expression_IfThen_IfClause::has_if_() const {
+  return _internal_has_if_();
+}
+inline void Expression_IfThen_IfClause::clear_if_() {
+  if (GetArenaForAllocation() == nullptr && if__ != nullptr) {
+    delete if__;
+  }
+  if__ = nullptr;
+}
+inline const ::substrait::Expression& Expression_IfThen_IfClause::_internal_if_() const {
+  const ::substrait::Expression* p = if__;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& Expression_IfThen_IfClause::if_() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.IfThen.IfClause.if)
+  return _internal_if_();
+}
+inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_if_(
+    ::substrait::Expression* if_) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__);
+  }
+  if__ = if_;
+  if (if_) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.IfThen.IfClause.if)
+}
+inline ::substrait::Expression* Expression_IfThen_IfClause::release_if_() {
+  
+  ::substrait::Expression* temp = if__;
+  if__ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_if_() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.IfThen.IfClause.if)
+  
+  ::substrait::Expression* temp = if__;
+  if__ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_if_() {
+  
+  if (if__ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    if__ = p;
+  }
+  return if__;
+}
+inline ::substrait::Expression* Expression_IfThen_IfClause::mutable_if_() {
+  ::substrait::Expression* _msg = _internal_mutable_if_();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.IfClause.if)
+  return _msg;
+}
+inline void Expression_IfThen_IfClause::set_allocated_if_(::substrait::Expression* if_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete if__;
+  }
+  if (if_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(if_);
+    if (message_arena != submessage_arena) {
+      if_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, if_, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  if__ = if_;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.IfThen.IfClause.if)
+}
+
+// .substrait.Expression then = 2;
+inline bool Expression_IfThen_IfClause::_internal_has_then() const {
+  return this != internal_default_instance() && then_ != nullptr;
+}
+inline bool Expression_IfThen_IfClause::has_then() const {
+  return _internal_has_then();
+}
+inline void Expression_IfThen_IfClause::clear_then() {
+  if (GetArenaForAllocation() == nullptr && then_ != nullptr) {
+    delete then_;
+  }
+  then_ = nullptr;
+}
+inline const ::substrait::Expression& Expression_IfThen_IfClause::_internal_then() const {
+  const ::substrait::Expression* p = then_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& Expression_IfThen_IfClause::then() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.IfThen.IfClause.then)
+  return _internal_then();
+}
+inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_then(
+    ::substrait::Expression* then) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_);
+  }
+  then_ = then;
+  if (then) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.IfThen.IfClause.then)
+}
+inline ::substrait::Expression* Expression_IfThen_IfClause::release_then() {
+  
+  ::substrait::Expression* temp = then_;
+  then_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_then() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.IfThen.IfClause.then)
+  
+  ::substrait::Expression* temp = then_;
+  then_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_then() {
+  
+  if (then_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    then_ = p;
+  }
+  return then_;
+}
+inline ::substrait::Expression* Expression_IfThen_IfClause::mutable_then() {
+  ::substrait::Expression* _msg = _internal_mutable_then();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.IfClause.then)
+  return _msg;
+}
+inline void Expression_IfThen_IfClause::set_allocated_then(::substrait::Expression* then) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete then_;
+  }
+  if (then) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(then);
+    if (message_arena != submessage_arena) {
+      then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, then, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  then_ = then;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.IfThen.IfClause.then)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_IfThen
+
+// repeated .substrait.Expression.IfThen.IfClause ifs = 1;
+inline int Expression_IfThen::_internal_ifs_size() const {
+  return ifs_.size();
+}
+inline int Expression_IfThen::ifs_size() const {
+  return _internal_ifs_size();
+}
+inline void Expression_IfThen::clear_ifs() {
+  ifs_.Clear();
+}
+inline ::substrait::Expression_IfThen_IfClause* Expression_IfThen::mutable_ifs(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.ifs)
+  return ifs_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >*
+Expression_IfThen::mutable_ifs() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.IfThen.ifs)
+  return &ifs_;
+}
+inline const ::substrait::Expression_IfThen_IfClause& Expression_IfThen::_internal_ifs(int index) const {
+  return ifs_.Get(index);
+}
+inline const ::substrait::Expression_IfThen_IfClause& Expression_IfThen::ifs(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.IfThen.ifs)
+  return _internal_ifs(index);
+}
+inline ::substrait::Expression_IfThen_IfClause* Expression_IfThen::_internal_add_ifs() {
+  return ifs_.Add();
+}
+inline ::substrait::Expression_IfThen_IfClause* Expression_IfThen::add_ifs() {
+  ::substrait::Expression_IfThen_IfClause* _add = _internal_add_ifs();
+  // @@protoc_insertion_point(field_add:substrait.Expression.IfThen.ifs)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >&
+Expression_IfThen::ifs() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.IfThen.ifs)
+  return ifs_;
+}
+
+// .substrait.Expression else = 2;
+inline bool Expression_IfThen::_internal_has_else_() const {
+  return this != internal_default_instance() && else__ != nullptr;
+}
+inline bool Expression_IfThen::has_else_() const {
+  return _internal_has_else_();
+}
+inline void Expression_IfThen::clear_else_() {
+  if (GetArenaForAllocation() == nullptr && else__ != nullptr) {
+    delete else__;
+  }
+  else__ = nullptr;
+}
+inline const ::substrait::Expression& Expression_IfThen::_internal_else_() const {
+  const ::substrait::Expression* p = else__;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& Expression_IfThen::else_() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.IfThen.else)
+  return _internal_else_();
+}
+inline void Expression_IfThen::unsafe_arena_set_allocated_else_(
+    ::substrait::Expression* else_) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__);
+  }
+  else__ = else_;
+  if (else_) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.IfThen.else)
+}
+inline ::substrait::Expression* Expression_IfThen::release_else_() {
+  
+  ::substrait::Expression* temp = else__;
+  else__ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* Expression_IfThen::unsafe_arena_release_else_() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.IfThen.else)
+  
+  ::substrait::Expression* temp = else__;
+  else__ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* Expression_IfThen::_internal_mutable_else_() {
+  
+  if (else__ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    else__ = p;
+  }
+  return else__;
+}
+inline ::substrait::Expression* Expression_IfThen::mutable_else_() {
+  ::substrait::Expression* _msg = _internal_mutable_else_();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.else)
+  return _msg;
+}
+inline void Expression_IfThen::set_allocated_else_(::substrait::Expression* else_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete else__;
+  }
+  if (else_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(else_);
+    if (message_arena != submessage_arena) {
+      else_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, else_, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  else__ = else_;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.IfThen.else)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_Cast
+
+// .substrait.Type type = 1;
+inline bool Expression_Cast::_internal_has_type() const {
+  return this != internal_default_instance() && type_ != nullptr;
+}
+inline bool Expression_Cast::has_type() const {
+  return _internal_has_type();
+}
+inline const ::substrait::Type& Expression_Cast::_internal_type() const {
+  const ::substrait::Type* p = type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Type&>(
+      ::substrait::_Type_default_instance_);
+}
+inline const ::substrait::Type& Expression_Cast::type() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Cast.type)
+  return _internal_type();
+}
+inline void Expression_Cast::unsafe_arena_set_allocated_type(
+    ::substrait::Type* type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
+  }
+  type_ = type;
+  if (type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Cast.type)
+}
+inline ::substrait::Type* Expression_Cast::release_type() {
+  
+  ::substrait::Type* temp = type_;
+  type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Type* Expression_Cast::unsafe_arena_release_type() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Cast.type)
+  
+  ::substrait::Type* temp = type_;
+  type_ = nullptr;
+  return temp;
+}
+inline ::substrait::Type* Expression_Cast::_internal_mutable_type() {
+  
+  if (type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation());
+    type_ = p;
+  }
+  return type_;
+}
+inline ::substrait::Type* Expression_Cast::mutable_type() {
+  ::substrait::Type* _msg = _internal_mutable_type();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Cast.type)
+  return _msg;
+}
+inline void Expression_Cast::set_allocated_type(::substrait::Type* type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
+  }
+  if (type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type));
+    if (message_arena != submessage_arena) {
+      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  type_ = type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Cast.type)
+}
+
+// .substrait.Expression input = 2;
+inline bool Expression_Cast::_internal_has_input() const {
+  return this != internal_default_instance() && input_ != nullptr;
+}
+inline bool Expression_Cast::has_input() const {
+  return _internal_has_input();
+}
+inline void Expression_Cast::clear_input() {
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+}
+inline const ::substrait::Expression& Expression_Cast::_internal_input() const {
+  const ::substrait::Expression* p = input_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& Expression_Cast::input() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.Cast.input)
+  return _internal_input();
+}
+inline void Expression_Cast::unsafe_arena_set_allocated_input(
+    ::substrait::Expression* input) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_);
+  }
+  input_ = input;
+  if (input) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Cast.input)
+}
+inline ::substrait::Expression* Expression_Cast::release_input() {
+  
+  ::substrait::Expression* temp = input_;
+  input_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* Expression_Cast::unsafe_arena_release_input() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.Cast.input)
+  
+  ::substrait::Expression* temp = input_;
+  input_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* Expression_Cast::_internal_mutable_input() {
+  
+  if (input_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    input_ = p;
+  }
+  return input_;
+}
+inline ::substrait::Expression* Expression_Cast::mutable_input() {
+  ::substrait::Expression* _msg = _internal_mutable_input();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.Cast.input)
+  return _msg;
+}
+inline void Expression_Cast::set_allocated_input(::substrait::Expression* input) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete input_;
+  }
+  if (input) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(input);
+    if (message_arena != submessage_arena) {
+      input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, input, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  input_ = input;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Cast.input)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_SwitchExpression_IfValue
+
+// .substrait.Expression.Literal if = 1;
+inline bool Expression_SwitchExpression_IfValue::_internal_has_if_() const {
+  return this != internal_default_instance() && if__ != nullptr;
+}
+inline bool Expression_SwitchExpression_IfValue::has_if_() const {
+  return _internal_has_if_();
+}
+inline void Expression_SwitchExpression_IfValue::clear_if_() {
+  if (GetArenaForAllocation() == nullptr && if__ != nullptr) {
+    delete if__;
+  }
+  if__ = nullptr;
+}
+inline const ::substrait::Expression_Literal& Expression_SwitchExpression_IfValue::_internal_if_() const {
+  const ::substrait::Expression_Literal* p = if__;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_Literal&>(
+      ::substrait::_Expression_Literal_default_instance_);
+}
+inline const ::substrait::Expression_Literal& Expression_SwitchExpression_IfValue::if_() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.SwitchExpression.IfValue.if)
+  return _internal_if_();
+}
+inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_if_(
+    ::substrait::Expression_Literal* if_) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__);
+  }
+  if__ = if_;
+  if (if_) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.SwitchExpression.IfValue.if)
+}
+inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::release_if_() {
+  
+  ::substrait::Expression_Literal* temp = if__;
+  if__ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::unsafe_arena_release_if_() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.SwitchExpression.IfValue.if)
+  
+  ::substrait::Expression_Literal* temp = if__;
+  if__ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::_internal_mutable_if_() {
+  
+  if (if__ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArenaForAllocation());
+    if__ = p;
+  }
+  return if__;
+}
+inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::mutable_if_() {
+  ::substrait::Expression_Literal* _msg = _internal_mutable_if_();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.IfValue.if)
+  return _msg;
+}
+inline void Expression_SwitchExpression_IfValue::set_allocated_if_(::substrait::Expression_Literal* if_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete if__;
+  }
+  if (if_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(if_);
+    if (message_arena != submessage_arena) {
+      if_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, if_, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  if__ = if_;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.SwitchExpression.IfValue.if)
+}
+
+// .substrait.Expression then = 2;
+inline bool Expression_SwitchExpression_IfValue::_internal_has_then() const {
+  return this != internal_default_instance() && then_ != nullptr;
+}
+inline bool Expression_SwitchExpression_IfValue::has_then() const {
+  return _internal_has_then();
+}
+inline void Expression_SwitchExpression_IfValue::clear_then() {
+  if (GetArenaForAllocation() == nullptr && then_ != nullptr) {
+    delete then_;
+  }
+  then_ = nullptr;
+}
+inline const ::substrait::Expression& Expression_SwitchExpression_IfValue::_internal_then() const {
+  const ::substrait::Expression* p = then_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& Expression_SwitchExpression_IfValue::then() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.SwitchExpression.IfValue.then)
+  return _internal_then();
+}
+inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_then(
+    ::substrait::Expression* then) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_);
+  }
+  then_ = then;
+  if (then) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.SwitchExpression.IfValue.then)
+}
+inline ::substrait::Expression* Expression_SwitchExpression_IfValue::release_then() {
+  
+  ::substrait::Expression* temp = then_;
+  then_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* Expression_SwitchExpression_IfValue::unsafe_arena_release_then() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.SwitchExpression.IfValue.then)
+  
+  ::substrait::Expression* temp = then_;
+  then_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* Expression_SwitchExpression_IfValue::_internal_mutable_then() {
+  
+  if (then_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    then_ = p;
+  }
+  return then_;
+}
+inline ::substrait::Expression* Expression_SwitchExpression_IfValue::mutable_then() {
+  ::substrait::Expression* _msg = _internal_mutable_then();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.IfValue.then)
+  return _msg;
+}
+inline void Expression_SwitchExpression_IfValue::set_allocated_then(::substrait::Expression* then) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete then_;
+  }
+  if (then) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(then);
+    if (message_arena != submessage_arena) {
+      then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, then, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  then_ = then;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.SwitchExpression.IfValue.then)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_SwitchExpression
+
+// repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1;
+inline int Expression_SwitchExpression::_internal_ifs_size() const {
+  return ifs_.size();
+}
+inline int Expression_SwitchExpression::ifs_size() const {
+  return _internal_ifs_size();
+}
+inline void Expression_SwitchExpression::clear_ifs() {
+  ifs_.Clear();
+}
+inline ::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::mutable_ifs(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.ifs)
+  return ifs_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >*
+Expression_SwitchExpression::mutable_ifs() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.SwitchExpression.ifs)
+  return &ifs_;
+}
+inline const ::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::_internal_ifs(int index) const {
+  return ifs_.Get(index);
+}
+inline const ::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::ifs(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.SwitchExpression.ifs)
+  return _internal_ifs(index);
+}
+inline ::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::_internal_add_ifs() {
+  return ifs_.Add();
+}
+inline ::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::add_ifs() {
+  ::substrait::Expression_SwitchExpression_IfValue* _add = _internal_add_ifs();
+  // @@protoc_insertion_point(field_add:substrait.Expression.SwitchExpression.ifs)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >&
+Expression_SwitchExpression::ifs() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.SwitchExpression.ifs)
+  return ifs_;
+}
+
+// .substrait.Expression else = 2;
+inline bool Expression_SwitchExpression::_internal_has_else_() const {
+  return this != internal_default_instance() && else__ != nullptr;
+}
+inline bool Expression_SwitchExpression::has_else_() const {
+  return _internal_has_else_();
+}
+inline void Expression_SwitchExpression::clear_else_() {
+  if (GetArenaForAllocation() == nullptr && else__ != nullptr) {
+    delete else__;
+  }
+  else__ = nullptr;
+}
+inline const ::substrait::Expression& Expression_SwitchExpression::_internal_else_() const {
+  const ::substrait::Expression* p = else__;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& Expression_SwitchExpression::else_() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.SwitchExpression.else)
+  return _internal_else_();
+}
+inline void Expression_SwitchExpression::unsafe_arena_set_allocated_else_(
+    ::substrait::Expression* else_) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__);
+  }
+  else__ = else_;
+  if (else_) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.SwitchExpression.else)
+}
+inline ::substrait::Expression* Expression_SwitchExpression::release_else_() {
+  
+  ::substrait::Expression* temp = else__;
+  else__ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* Expression_SwitchExpression::unsafe_arena_release_else_() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.SwitchExpression.else)
+  
+  ::substrait::Expression* temp = else__;
+  else__ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* Expression_SwitchExpression::_internal_mutable_else_() {
+  
+  if (else__ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    else__ = p;
+  }
+  return else__;
+}
+inline ::substrait::Expression* Expression_SwitchExpression::mutable_else_() {
+  ::substrait::Expression* _msg = _internal_mutable_else_();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.else)
+  return _msg;
+}
+inline void Expression_SwitchExpression::set_allocated_else_(::substrait::Expression* else_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete else__;
+  }
+  if (else_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(else_);
+    if (message_arena != submessage_arena) {
+      else_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, else_, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  else__ = else_;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.SwitchExpression.else)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_SingularOrList
+
+// .substrait.Expression value = 1;
+inline bool Expression_SingularOrList::_internal_has_value() const {
+  return this != internal_default_instance() && value_ != nullptr;
+}
+inline bool Expression_SingularOrList::has_value() const {
+  return _internal_has_value();
+}
+inline void Expression_SingularOrList::clear_value() {
+  if (GetArenaForAllocation() == nullptr && value_ != nullptr) {
+    delete value_;
+  }
+  value_ = nullptr;
+}
+inline const ::substrait::Expression& Expression_SingularOrList::_internal_value() const {
+  const ::substrait::Expression* p = value_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& Expression_SingularOrList::value() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.SingularOrList.value)
+  return _internal_value();
+}
+inline void Expression_SingularOrList::unsafe_arena_set_allocated_value(
+    ::substrait::Expression* value) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
+  }
+  value_ = value;
+  if (value) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.SingularOrList.value)
+}
+inline ::substrait::Expression* Expression_SingularOrList::release_value() {
+  
+  ::substrait::Expression* temp = value_;
+  value_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* Expression_SingularOrList::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.SingularOrList.value)
+  
+  ::substrait::Expression* temp = value_;
+  value_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* Expression_SingularOrList::_internal_mutable_value() {
+  
+  if (value_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    value_ = p;
+  }
+  return value_;
+}
+inline ::substrait::Expression* Expression_SingularOrList::mutable_value() {
+  ::substrait::Expression* _msg = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.SingularOrList.value)
+  return _msg;
+}
+inline void Expression_SingularOrList::set_allocated_value(::substrait::Expression* value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete value_;
+  }
+  if (value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(value);
+    if (message_arena != submessage_arena) {
+      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  value_ = value;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.SingularOrList.value)
+}
+
+// repeated .substrait.Expression options = 2;
+inline int Expression_SingularOrList::_internal_options_size() const {
+  return options_.size();
+}
+inline int Expression_SingularOrList::options_size() const {
+  return _internal_options_size();
+}
+inline void Expression_SingularOrList::clear_options() {
+  options_.Clear();
+}
+inline ::substrait::Expression* Expression_SingularOrList::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.SingularOrList.options)
+  return options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+Expression_SingularOrList::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.SingularOrList.options)
+  return &options_;
+}
+inline const ::substrait::Expression& Expression_SingularOrList::_internal_options(int index) const {
+  return options_.Get(index);
+}
+inline const ::substrait::Expression& Expression_SingularOrList::options(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.SingularOrList.options)
+  return _internal_options(index);
+}
+inline ::substrait::Expression* Expression_SingularOrList::_internal_add_options() {
+  return options_.Add();
+}
+inline ::substrait::Expression* Expression_SingularOrList::add_options() {
+  ::substrait::Expression* _add = _internal_add_options();
+  // @@protoc_insertion_point(field_add:substrait.Expression.SingularOrList.options)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+Expression_SingularOrList::options() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.SingularOrList.options)
+  return options_;
+}
+
+// -------------------------------------------------------------------
+
+// Expression_MultiOrList_Record
+
+// repeated .substrait.Expression fields = 1;
+inline int Expression_MultiOrList_Record::_internal_fields_size() const {
+  return fields_.size();
+}
+inline int Expression_MultiOrList_Record::fields_size() const {
+  return _internal_fields_size();
+}
+inline void Expression_MultiOrList_Record::clear_fields() {
+  fields_.Clear();
+}
+inline ::substrait::Expression* Expression_MultiOrList_Record::mutable_fields(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MultiOrList.Record.fields)
+  return fields_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+Expression_MultiOrList_Record::mutable_fields() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MultiOrList.Record.fields)
+  return &fields_;
+}
+inline const ::substrait::Expression& Expression_MultiOrList_Record::_internal_fields(int index) const {
+  return fields_.Get(index);
+}
+inline const ::substrait::Expression& Expression_MultiOrList_Record::fields(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MultiOrList.Record.fields)
+  return _internal_fields(index);
+}
+inline ::substrait::Expression* Expression_MultiOrList_Record::_internal_add_fields() {
+  return fields_.Add();
+}
+inline ::substrait::Expression* Expression_MultiOrList_Record::add_fields() {
+  ::substrait::Expression* _add = _internal_add_fields();
+  // @@protoc_insertion_point(field_add:substrait.Expression.MultiOrList.Record.fields)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+Expression_MultiOrList_Record::fields() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.MultiOrList.Record.fields)
+  return fields_;
+}
+
+// -------------------------------------------------------------------
+
+// Expression_MultiOrList
+
+// repeated .substrait.Expression value = 1;
+inline int Expression_MultiOrList::_internal_value_size() const {
+  return value_.size();
+}
+inline int Expression_MultiOrList::value_size() const {
+  return _internal_value_size();
+}
+inline void Expression_MultiOrList::clear_value() {
+  value_.Clear();
+}
+inline ::substrait::Expression* Expression_MultiOrList::mutable_value(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MultiOrList.value)
+  return value_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+Expression_MultiOrList::mutable_value() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MultiOrList.value)
+  return &value_;
+}
+inline const ::substrait::Expression& Expression_MultiOrList::_internal_value(int index) const {
+  return value_.Get(index);
+}
+inline const ::substrait::Expression& Expression_MultiOrList::value(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MultiOrList.value)
+  return _internal_value(index);
+}
+inline ::substrait::Expression* Expression_MultiOrList::_internal_add_value() {
+  return value_.Add();
+}
+inline ::substrait::Expression* Expression_MultiOrList::add_value() {
+  ::substrait::Expression* _add = _internal_add_value();
+  // @@protoc_insertion_point(field_add:substrait.Expression.MultiOrList.value)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+Expression_MultiOrList::value() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.MultiOrList.value)
+  return value_;
+}
+
+// repeated .substrait.Expression.MultiOrList.Record options = 2;
+inline int Expression_MultiOrList::_internal_options_size() const {
+  return options_.size();
+}
+inline int Expression_MultiOrList::options_size() const {
+  return _internal_options_size();
+}
+inline void Expression_MultiOrList::clear_options() {
+  options_.Clear();
+}
+inline ::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MultiOrList.options)
+  return options_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >*
+Expression_MultiOrList::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MultiOrList.options)
+  return &options_;
+}
+inline const ::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::_internal_options(int index) const {
+  return options_.Get(index);
+}
+inline const ::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::options(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MultiOrList.options)
+  return _internal_options(index);
+}
+inline ::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::_internal_add_options() {
+  return options_.Add();
+}
+inline ::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::add_options() {
+  ::substrait::Expression_MultiOrList_Record* _add = _internal_add_options();
+  // @@protoc_insertion_point(field_add:substrait.Expression.MultiOrList.options)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >&
+Expression_MultiOrList::options() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.MultiOrList.options)
+  return options_;
+}
+
+// -------------------------------------------------------------------
+
+// Expression_EmbeddedFunction_PythonPickleFunction
+
+// bytes function = 1;
+inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_function() {
+  function_.ClearToEmpty();
+}
+inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::function() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function)
+  return _internal_function();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Expression_EmbeddedFunction_PythonPickleFunction::set_function(ArgT0&& arg0, ArgT... args) {
+ 
+ function_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function)
+}
+inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_function() {
+  std::string* _s = _internal_mutable_function();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function)
+  return _s;
+}
+inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_function() const {
+  return function_.Get();
+}
+inline void Expression_EmbeddedFunction_PythonPickleFunction::_internal_set_function(const std::string& value) {
+  
+  function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_mutable_function() {
+  
+  return function_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::release_function() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function)
+  return function_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void Expression_EmbeddedFunction_PythonPickleFunction::set_allocated_function(std::string* function) {
+  if (function != nullptr) {
+    
+  } else {
+    
+  }
+  function_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), function,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (function_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    function_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function)
+}
+
+// repeated string prerequisite = 2;
+inline int Expression_EmbeddedFunction_PythonPickleFunction::_internal_prerequisite_size() const {
+  return prerequisite_.size();
+}
+inline int Expression_EmbeddedFunction_PythonPickleFunction::prerequisite_size() const {
+  return _internal_prerequisite_size();
+}
+inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_prerequisite() {
+  prerequisite_.Clear();
+}
+inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite() {
+  std::string* _s = _internal_add_prerequisite();
+  // @@protoc_insertion_point(field_add_mutable:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+  return _s;
+}
+inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_prerequisite(int index) const {
+  return prerequisite_.Get(index);
+}
+inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::prerequisite(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+  return _internal_prerequisite(index);
+}
+inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_prerequisite(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+  return prerequisite_.Mutable(index);
+}
+inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const std::string& value) {
+  prerequisite_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+}
+inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, std::string&& value) {
+  prerequisite_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+}
+inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  prerequisite_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+}
+inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value, size_t size) {
+  prerequisite_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+}
+inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_add_prerequisite() {
+  return prerequisite_.Add();
+}
+inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const std::string& value) {
+  prerequisite_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+}
+inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(std::string&& value) {
+  prerequisite_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+}
+inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  prerequisite_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+}
+inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const char* value, size_t size) {
+  prerequisite_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Expression_EmbeddedFunction_PythonPickleFunction::prerequisite() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+  return prerequisite_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Expression_EmbeddedFunction_PythonPickleFunction::mutable_prerequisite() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite)
+  return &prerequisite_;
+}
+
+// -------------------------------------------------------------------
+
+// Expression_EmbeddedFunction_WebAssemblyFunction
+
+// bytes script = 1;
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_script() {
+  script_.ClearToEmpty();
+}
+inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::script() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script)
+  return _internal_script();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Expression_EmbeddedFunction_WebAssemblyFunction::set_script(ArgT0&& arg0, ArgT... args) {
+ 
+ script_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script)
+}
+inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_script() {
+  std::string* _s = _internal_mutable_script();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script)
+  return _s;
+}
+inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_script() const {
+  return script_.Get();
+}
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::_internal_set_script(const std::string& value) {
+  
+  script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_mutable_script() {
+  
+  return script_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::release_script() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script)
+  return script_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_allocated_script(std::string* script) {
+  if (script != nullptr) {
+    
+  } else {
+    
+  }
+  script_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), script,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (script_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    script_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script)
+}
+
+// repeated string prerequisite = 2;
+inline int Expression_EmbeddedFunction_WebAssemblyFunction::_internal_prerequisite_size() const {
+  return prerequisite_.size();
+}
+inline int Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite_size() const {
+  return _internal_prerequisite_size();
+}
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_prerequisite() {
+  prerequisite_.Clear();
+}
+inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite() {
+  std::string* _s = _internal_add_prerequisite();
+  // @@protoc_insertion_point(field_add_mutable:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+  return _s;
+}
+inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_prerequisite(int index) const {
+  return prerequisite_.Get(index);
+}
+inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+  return _internal_prerequisite(index);
+}
+inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+  return prerequisite_.Mutable(index);
+}
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const std::string& value) {
+  prerequisite_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+}
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, std::string&& value) {
+  prerequisite_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+}
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  prerequisite_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+}
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value, size_t size) {
+  prerequisite_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+}
+inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_add_prerequisite() {
+  return prerequisite_.Add();
+}
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const std::string& value) {
+  prerequisite_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+}
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(std::string&& value) {
+  prerequisite_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+}
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  prerequisite_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+}
+inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const char* value, size_t size) {
+  prerequisite_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+  return prerequisite_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite)
+  return &prerequisite_;
+}
+
+// -------------------------------------------------------------------
+
+// Expression_EmbeddedFunction
+
+// repeated .substrait.Expression arguments = 1;
+inline int Expression_EmbeddedFunction::_internal_arguments_size() const {
+  return arguments_.size();
+}
+inline int Expression_EmbeddedFunction::arguments_size() const {
+  return _internal_arguments_size();
+}
+inline void Expression_EmbeddedFunction::clear_arguments() {
+  arguments_.Clear();
+}
+inline ::substrait::Expression* Expression_EmbeddedFunction::mutable_arguments(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.arguments)
+  return arguments_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+Expression_EmbeddedFunction::mutable_arguments() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.EmbeddedFunction.arguments)
+  return &arguments_;
+}
+inline const ::substrait::Expression& Expression_EmbeddedFunction::_internal_arguments(int index) const {
+  return arguments_.Get(index);
+}
+inline const ::substrait::Expression& Expression_EmbeddedFunction::arguments(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.arguments)
+  return _internal_arguments(index);
+}
+inline ::substrait::Expression* Expression_EmbeddedFunction::_internal_add_arguments() {
+  return arguments_.Add();
+}
+inline ::substrait::Expression* Expression_EmbeddedFunction::add_arguments() {
+  ::substrait::Expression* _add = _internal_add_arguments();
+  // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.arguments)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+Expression_EmbeddedFunction::arguments() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.EmbeddedFunction.arguments)
+  return arguments_;
+}
+
+// .substrait.Type output_type = 2;
+inline bool Expression_EmbeddedFunction::_internal_has_output_type() const {
+  return this != internal_default_instance() && output_type_ != nullptr;
+}
+inline bool Expression_EmbeddedFunction::has_output_type() const {
+  return _internal_has_output_type();
+}
+inline const ::substrait::Type& Expression_EmbeddedFunction::_internal_output_type() const {
+  const ::substrait::Type* p = output_type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Type&>(
+      ::substrait::_Type_default_instance_);
+}
+inline const ::substrait::Type& Expression_EmbeddedFunction::output_type() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.output_type)
+  return _internal_output_type();
+}
+inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_output_type(
+    ::substrait::Type* output_type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  output_type_ = output_type;
+  if (output_type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.EmbeddedFunction.output_type)
+}
+inline ::substrait::Type* Expression_EmbeddedFunction::release_output_type() {
+  
+  ::substrait::Type* temp = output_type_;
+  output_type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Type* Expression_EmbeddedFunction::unsafe_arena_release_output_type() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.output_type)
+  
+  ::substrait::Type* temp = output_type_;
+  output_type_ = nullptr;
+  return temp;
+}
+inline ::substrait::Type* Expression_EmbeddedFunction::_internal_mutable_output_type() {
+  
+  if (output_type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation());
+    output_type_ = p;
+  }
+  return output_type_;
+}
+inline ::substrait::Type* Expression_EmbeddedFunction::mutable_output_type() {
+  ::substrait::Type* _msg = _internal_mutable_output_type();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.output_type)
+  return _msg;
+}
+inline void Expression_EmbeddedFunction::set_allocated_output_type(::substrait::Type* output_type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  if (output_type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type));
+    if (message_arena != submessage_arena) {
+      output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, output_type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  output_type_ = output_type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.output_type)
+}
+
+// .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3;
+inline bool Expression_EmbeddedFunction::_internal_has_python_pickle_function() const {
+  return kind_case() == kPythonPickleFunction;
+}
+inline bool Expression_EmbeddedFunction::has_python_pickle_function() const {
+  return _internal_has_python_pickle_function();
+}
+inline void Expression_EmbeddedFunction::set_has_python_pickle_function() {
+  _oneof_case_[0] = kPythonPickleFunction;
+}
+inline void Expression_EmbeddedFunction::clear_python_pickle_function() {
+  if (_internal_has_python_pickle_function()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.python_pickle_function_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::release_python_pickle_function() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.python_pickle_function)
+  if (_internal_has_python_pickle_function()) {
+    clear_has_kind();
+      ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.python_pickle_function_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::_internal_python_pickle_function() const {
+  return _internal_has_python_pickle_function()
+      ? *kind_.python_pickle_function_
+      : reinterpret_cast< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction&>(::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_);
+}
+inline const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::python_pickle_function() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.python_pickle_function)
+  return _internal_python_pickle_function();
+}
+inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::unsafe_arena_release_python_pickle_function() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.EmbeddedFunction.python_pickle_function)
+  if (_internal_has_python_pickle_function()) {
+    clear_has_kind();
+    ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_;
+    kind_.python_pickle_function_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_python_pickle_function(::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) {
+  clear_kind();
+  if (python_pickle_function) {
+    set_has_python_pickle_function();
+    kind_.python_pickle_function_ = python_pickle_function;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.EmbeddedFunction.python_pickle_function)
+}
+inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::_internal_mutable_python_pickle_function() {
+  if (!_internal_has_python_pickle_function()) {
+    clear_kind();
+    set_has_python_pickle_function();
+    kind_.python_pickle_function_ = CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(GetArenaForAllocation());
+  }
+  return kind_.python_pickle_function_;
+}
+inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::mutable_python_pickle_function() {
+  ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* _msg = _internal_mutable_python_pickle_function();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.python_pickle_function)
+  return _msg;
+}
+
+// .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4;
+inline bool Expression_EmbeddedFunction::_internal_has_web_assembly_function() const {
+  return kind_case() == kWebAssemblyFunction;
+}
+inline bool Expression_EmbeddedFunction::has_web_assembly_function() const {
+  return _internal_has_web_assembly_function();
+}
+inline void Expression_EmbeddedFunction::set_has_web_assembly_function() {
+  _oneof_case_[0] = kWebAssemblyFunction;
+}
+inline void Expression_EmbeddedFunction::clear_web_assembly_function() {
+  if (_internal_has_web_assembly_function()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.web_assembly_function_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::release_web_assembly_function() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.web_assembly_function)
+  if (_internal_has_web_assembly_function()) {
+    clear_has_kind();
+      ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.web_assembly_function_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::_internal_web_assembly_function() const {
+  return _internal_has_web_assembly_function()
+      ? *kind_.web_assembly_function_
+      : reinterpret_cast< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction&>(::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_);
+}
+inline const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::web_assembly_function() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.web_assembly_function)
+  return _internal_web_assembly_function();
+}
+inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::unsafe_arena_release_web_assembly_function() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.EmbeddedFunction.web_assembly_function)
+  if (_internal_has_web_assembly_function()) {
+    clear_has_kind();
+    ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_;
+    kind_.web_assembly_function_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_web_assembly_function(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) {
+  clear_kind();
+  if (web_assembly_function) {
+    set_has_web_assembly_function();
+    kind_.web_assembly_function_ = web_assembly_function;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.EmbeddedFunction.web_assembly_function)
+}
+inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::_internal_mutable_web_assembly_function() {
+  if (!_internal_has_web_assembly_function()) {
+    clear_kind();
+    set_has_web_assembly_function();
+    kind_.web_assembly_function_ = CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(GetArenaForAllocation());
+  }
+  return kind_.web_assembly_function_;
+}
+inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::mutable_web_assembly_function() {
+  ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* _msg = _internal_mutable_web_assembly_function();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.web_assembly_function)
+  return _msg;
+}
+
+inline bool Expression_EmbeddedFunction::has_kind() const {
+  return kind_case() != KIND_NOT_SET;
+}
+inline void Expression_EmbeddedFunction::clear_has_kind() {
+  _oneof_case_[0] = KIND_NOT_SET;
+}
+inline Expression_EmbeddedFunction::KindCase Expression_EmbeddedFunction::kind_case() const {
+  return Expression_EmbeddedFunction::KindCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Expression_ReferenceSegment_MapKey
+
+// .substrait.Expression.Literal map_key = 1;
+inline bool Expression_ReferenceSegment_MapKey::_internal_has_map_key() const {
+  return this != internal_default_instance() && map_key_ != nullptr;
+}
+inline bool Expression_ReferenceSegment_MapKey::has_map_key() const {
+  return _internal_has_map_key();
+}
+inline void Expression_ReferenceSegment_MapKey::clear_map_key() {
+  if (GetArenaForAllocation() == nullptr && map_key_ != nullptr) {
+    delete map_key_;
+  }
+  map_key_ = nullptr;
+}
+inline const ::substrait::Expression_Literal& Expression_ReferenceSegment_MapKey::_internal_map_key() const {
+  const ::substrait::Expression_Literal* p = map_key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_Literal&>(
+      ::substrait::_Expression_Literal_default_instance_);
+}
+inline const ::substrait::Expression_Literal& Expression_ReferenceSegment_MapKey::map_key() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.MapKey.map_key)
+  return _internal_map_key();
+}
+inline void Expression_ReferenceSegment_MapKey::unsafe_arena_set_allocated_map_key(
+    ::substrait::Expression_Literal* map_key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(map_key_);
+  }
+  map_key_ = map_key;
+  if (map_key) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.MapKey.map_key)
+}
+inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::release_map_key() {
+  
+  ::substrait::Expression_Literal* temp = map_key_;
+  map_key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::unsafe_arena_release_map_key() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.MapKey.map_key)
+  
+  ::substrait::Expression_Literal* temp = map_key_;
+  map_key_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::_internal_mutable_map_key() {
+  
+  if (map_key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArenaForAllocation());
+    map_key_ = p;
+  }
+  return map_key_;
+}
+inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::mutable_map_key() {
+  ::substrait::Expression_Literal* _msg = _internal_mutable_map_key();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.MapKey.map_key)
+  return _msg;
+}
+inline void Expression_ReferenceSegment_MapKey::set_allocated_map_key(::substrait::Expression_Literal* map_key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete map_key_;
+  }
+  if (map_key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(map_key);
+    if (message_arena != submessage_arena) {
+      map_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, map_key, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  map_key_ = map_key;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.MapKey.map_key)
+}
+
+// .substrait.Expression.ReferenceSegment child = 2;
+inline bool Expression_ReferenceSegment_MapKey::_internal_has_child() const {
+  return this != internal_default_instance() && child_ != nullptr;
+}
+inline bool Expression_ReferenceSegment_MapKey::has_child() const {
+  return _internal_has_child();
+}
+inline void Expression_ReferenceSegment_MapKey::clear_child() {
+  if (GetArenaForAllocation() == nullptr && child_ != nullptr) {
+    delete child_;
+  }
+  child_ = nullptr;
+}
+inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_MapKey::_internal_child() const {
+  const ::substrait::Expression_ReferenceSegment* p = child_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_ReferenceSegment&>(
+      ::substrait::_Expression_ReferenceSegment_default_instance_);
+}
+inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_MapKey::child() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.MapKey.child)
+  return _internal_child();
+}
+inline void Expression_ReferenceSegment_MapKey::unsafe_arena_set_allocated_child(
+    ::substrait::Expression_ReferenceSegment* child) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_);
+  }
+  child_ = child;
+  if (child) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.MapKey.child)
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::release_child() {
+  
+  ::substrait::Expression_ReferenceSegment* temp = child_;
+  child_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::unsafe_arena_release_child() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.MapKey.child)
+  
+  ::substrait::Expression_ReferenceSegment* temp = child_;
+  child_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::_internal_mutable_child() {
+  
+  if (child_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArenaForAllocation());
+    child_ = p;
+  }
+  return child_;
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::mutable_child() {
+  ::substrait::Expression_ReferenceSegment* _msg = _internal_mutable_child();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.MapKey.child)
+  return _msg;
+}
+inline void Expression_ReferenceSegment_MapKey::set_allocated_child(::substrait::Expression_ReferenceSegment* child) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete child_;
+  }
+  if (child) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(child);
+    if (message_arena != submessage_arena) {
+      child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, child, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  child_ = child;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.MapKey.child)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_ReferenceSegment_StructField
+
+// int32 field = 1;
+inline void Expression_ReferenceSegment_StructField::clear_field() {
+  field_ = 0;
+}
+inline int32_t Expression_ReferenceSegment_StructField::_internal_field() const {
+  return field_;
+}
+inline int32_t Expression_ReferenceSegment_StructField::field() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.StructField.field)
+  return _internal_field();
+}
+inline void Expression_ReferenceSegment_StructField::_internal_set_field(int32_t value) {
+  
+  field_ = value;
+}
+inline void Expression_ReferenceSegment_StructField::set_field(int32_t value) {
+  _internal_set_field(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.ReferenceSegment.StructField.field)
+}
+
+// .substrait.Expression.ReferenceSegment child = 2;
+inline bool Expression_ReferenceSegment_StructField::_internal_has_child() const {
+  return this != internal_default_instance() && child_ != nullptr;
+}
+inline bool Expression_ReferenceSegment_StructField::has_child() const {
+  return _internal_has_child();
+}
+inline void Expression_ReferenceSegment_StructField::clear_child() {
+  if (GetArenaForAllocation() == nullptr && child_ != nullptr) {
+    delete child_;
+  }
+  child_ = nullptr;
+}
+inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_StructField::_internal_child() const {
+  const ::substrait::Expression_ReferenceSegment* p = child_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_ReferenceSegment&>(
+      ::substrait::_Expression_ReferenceSegment_default_instance_);
+}
+inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_StructField::child() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.StructField.child)
+  return _internal_child();
+}
+inline void Expression_ReferenceSegment_StructField::unsafe_arena_set_allocated_child(
+    ::substrait::Expression_ReferenceSegment* child) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_);
+  }
+  child_ = child;
+  if (child) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.StructField.child)
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::release_child() {
+  
+  ::substrait::Expression_ReferenceSegment* temp = child_;
+  child_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::unsafe_arena_release_child() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.StructField.child)
+  
+  ::substrait::Expression_ReferenceSegment* temp = child_;
+  child_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::_internal_mutable_child() {
+  
+  if (child_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArenaForAllocation());
+    child_ = p;
+  }
+  return child_;
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::mutable_child() {
+  ::substrait::Expression_ReferenceSegment* _msg = _internal_mutable_child();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.StructField.child)
+  return _msg;
+}
+inline void Expression_ReferenceSegment_StructField::set_allocated_child(::substrait::Expression_ReferenceSegment* child) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete child_;
+  }
+  if (child) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(child);
+    if (message_arena != submessage_arena) {
+      child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, child, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  child_ = child;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.StructField.child)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_ReferenceSegment_ListElement
+
+// int32 offset = 1;
+inline void Expression_ReferenceSegment_ListElement::clear_offset() {
+  offset_ = 0;
+}
+inline int32_t Expression_ReferenceSegment_ListElement::_internal_offset() const {
+  return offset_;
+}
+inline int32_t Expression_ReferenceSegment_ListElement::offset() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.ListElement.offset)
+  return _internal_offset();
+}
+inline void Expression_ReferenceSegment_ListElement::_internal_set_offset(int32_t value) {
+  
+  offset_ = value;
+}
+inline void Expression_ReferenceSegment_ListElement::set_offset(int32_t value) {
+  _internal_set_offset(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.ReferenceSegment.ListElement.offset)
+}
+
+// .substrait.Expression.ReferenceSegment child = 2;
+inline bool Expression_ReferenceSegment_ListElement::_internal_has_child() const {
+  return this != internal_default_instance() && child_ != nullptr;
+}
+inline bool Expression_ReferenceSegment_ListElement::has_child() const {
+  return _internal_has_child();
+}
+inline void Expression_ReferenceSegment_ListElement::clear_child() {
+  if (GetArenaForAllocation() == nullptr && child_ != nullptr) {
+    delete child_;
+  }
+  child_ = nullptr;
+}
+inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_ListElement::_internal_child() const {
+  const ::substrait::Expression_ReferenceSegment* p = child_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_ReferenceSegment&>(
+      ::substrait::_Expression_ReferenceSegment_default_instance_);
+}
+inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_ListElement::child() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.ListElement.child)
+  return _internal_child();
+}
+inline void Expression_ReferenceSegment_ListElement::unsafe_arena_set_allocated_child(
+    ::substrait::Expression_ReferenceSegment* child) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_);
+  }
+  child_ = child;
+  if (child) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.ListElement.child)
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::release_child() {
+  
+  ::substrait::Expression_ReferenceSegment* temp = child_;
+  child_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::unsafe_arena_release_child() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.ListElement.child)
+  
+  ::substrait::Expression_ReferenceSegment* temp = child_;
+  child_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::_internal_mutable_child() {
+  
+  if (child_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArenaForAllocation());
+    child_ = p;
+  }
+  return child_;
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::mutable_child() {
+  ::substrait::Expression_ReferenceSegment* _msg = _internal_mutable_child();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.ListElement.child)
+  return _msg;
+}
+inline void Expression_ReferenceSegment_ListElement::set_allocated_child(::substrait::Expression_ReferenceSegment* child) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete child_;
+  }
+  if (child) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(child);
+    if (message_arena != submessage_arena) {
+      child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, child, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  child_ = child;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.ListElement.child)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_ReferenceSegment
+
+// .substrait.Expression.ReferenceSegment.MapKey map_key = 1;
+inline bool Expression_ReferenceSegment::_internal_has_map_key() const {
+  return reference_type_case() == kMapKey;
+}
+inline bool Expression_ReferenceSegment::has_map_key() const {
+  return _internal_has_map_key();
+}
+inline void Expression_ReferenceSegment::set_has_map_key() {
+  _oneof_case_[0] = kMapKey;
+}
+inline void Expression_ReferenceSegment::clear_map_key() {
+  if (_internal_has_map_key()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete reference_type_.map_key_;
+    }
+    clear_has_reference_type();
+  }
+}
+inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::release_map_key() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.map_key)
+  if (_internal_has_map_key()) {
+    clear_has_reference_type();
+      ::substrait::Expression_ReferenceSegment_MapKey* temp = reference_type_.map_key_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    reference_type_.map_key_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_ReferenceSegment_MapKey& Expression_ReferenceSegment::_internal_map_key() const {
+  return _internal_has_map_key()
+      ? *reference_type_.map_key_
+      : reinterpret_cast< ::substrait::Expression_ReferenceSegment_MapKey&>(::substrait::_Expression_ReferenceSegment_MapKey_default_instance_);
+}
+inline const ::substrait::Expression_ReferenceSegment_MapKey& Expression_ReferenceSegment::map_key() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.map_key)
+  return _internal_map_key();
+}
+inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::unsafe_arena_release_map_key() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.ReferenceSegment.map_key)
+  if (_internal_has_map_key()) {
+    clear_has_reference_type();
+    ::substrait::Expression_ReferenceSegment_MapKey* temp = reference_type_.map_key_;
+    reference_type_.map_key_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_map_key(::substrait::Expression_ReferenceSegment_MapKey* map_key) {
+  clear_reference_type();
+  if (map_key) {
+    set_has_map_key();
+    reference_type_.map_key_ = map_key;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.map_key)
+}
+inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::_internal_mutable_map_key() {
+  if (!_internal_has_map_key()) {
+    clear_reference_type();
+    set_has_map_key();
+    reference_type_.map_key_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_MapKey >(GetArenaForAllocation());
+  }
+  return reference_type_.map_key_;
+}
+inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::mutable_map_key() {
+  ::substrait::Expression_ReferenceSegment_MapKey* _msg = _internal_mutable_map_key();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.map_key)
+  return _msg;
+}
+
+// .substrait.Expression.ReferenceSegment.StructField struct_field = 2;
+inline bool Expression_ReferenceSegment::_internal_has_struct_field() const {
+  return reference_type_case() == kStructField;
+}
+inline bool Expression_ReferenceSegment::has_struct_field() const {
+  return _internal_has_struct_field();
+}
+inline void Expression_ReferenceSegment::set_has_struct_field() {
+  _oneof_case_[0] = kStructField;
+}
+inline void Expression_ReferenceSegment::clear_struct_field() {
+  if (_internal_has_struct_field()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete reference_type_.struct_field_;
+    }
+    clear_has_reference_type();
+  }
+}
+inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::release_struct_field() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.struct_field)
+  if (_internal_has_struct_field()) {
+    clear_has_reference_type();
+      ::substrait::Expression_ReferenceSegment_StructField* temp = reference_type_.struct_field_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    reference_type_.struct_field_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_ReferenceSegment_StructField& Expression_ReferenceSegment::_internal_struct_field() const {
+  return _internal_has_struct_field()
+      ? *reference_type_.struct_field_
+      : reinterpret_cast< ::substrait::Expression_ReferenceSegment_StructField&>(::substrait::_Expression_ReferenceSegment_StructField_default_instance_);
+}
+inline const ::substrait::Expression_ReferenceSegment_StructField& Expression_ReferenceSegment::struct_field() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.struct_field)
+  return _internal_struct_field();
+}
+inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::unsafe_arena_release_struct_field() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.ReferenceSegment.struct_field)
+  if (_internal_has_struct_field()) {
+    clear_has_reference_type();
+    ::substrait::Expression_ReferenceSegment_StructField* temp = reference_type_.struct_field_;
+    reference_type_.struct_field_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_struct_field(::substrait::Expression_ReferenceSegment_StructField* struct_field) {
+  clear_reference_type();
+  if (struct_field) {
+    set_has_struct_field();
+    reference_type_.struct_field_ = struct_field;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.struct_field)
+}
+inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::_internal_mutable_struct_field() {
+  if (!_internal_has_struct_field()) {
+    clear_reference_type();
+    set_has_struct_field();
+    reference_type_.struct_field_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_StructField >(GetArenaForAllocation());
+  }
+  return reference_type_.struct_field_;
+}
+inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::mutable_struct_field() {
+  ::substrait::Expression_ReferenceSegment_StructField* _msg = _internal_mutable_struct_field();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.struct_field)
+  return _msg;
+}
+
+// .substrait.Expression.ReferenceSegment.ListElement list_element = 3;
+inline bool Expression_ReferenceSegment::_internal_has_list_element() const {
+  return reference_type_case() == kListElement;
+}
+inline bool Expression_ReferenceSegment::has_list_element() const {
+  return _internal_has_list_element();
+}
+inline void Expression_ReferenceSegment::set_has_list_element() {
+  _oneof_case_[0] = kListElement;
+}
+inline void Expression_ReferenceSegment::clear_list_element() {
+  if (_internal_has_list_element()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete reference_type_.list_element_;
+    }
+    clear_has_reference_type();
+  }
+}
+inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::release_list_element() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.list_element)
+  if (_internal_has_list_element()) {
+    clear_has_reference_type();
+      ::substrait::Expression_ReferenceSegment_ListElement* temp = reference_type_.list_element_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    reference_type_.list_element_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_ReferenceSegment_ListElement& Expression_ReferenceSegment::_internal_list_element() const {
+  return _internal_has_list_element()
+      ? *reference_type_.list_element_
+      : reinterpret_cast< ::substrait::Expression_ReferenceSegment_ListElement&>(::substrait::_Expression_ReferenceSegment_ListElement_default_instance_);
+}
+inline const ::substrait::Expression_ReferenceSegment_ListElement& Expression_ReferenceSegment::list_element() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.list_element)
+  return _internal_list_element();
+}
+inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::unsafe_arena_release_list_element() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.ReferenceSegment.list_element)
+  if (_internal_has_list_element()) {
+    clear_has_reference_type();
+    ::substrait::Expression_ReferenceSegment_ListElement* temp = reference_type_.list_element_;
+    reference_type_.list_element_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_list_element(::substrait::Expression_ReferenceSegment_ListElement* list_element) {
+  clear_reference_type();
+  if (list_element) {
+    set_has_list_element();
+    reference_type_.list_element_ = list_element;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.list_element)
+}
+inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::_internal_mutable_list_element() {
+  if (!_internal_has_list_element()) {
+    clear_reference_type();
+    set_has_list_element();
+    reference_type_.list_element_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_ListElement >(GetArenaForAllocation());
+  }
+  return reference_type_.list_element_;
+}
+inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::mutable_list_element() {
+  ::substrait::Expression_ReferenceSegment_ListElement* _msg = _internal_mutable_list_element();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.list_element)
+  return _msg;
+}
+
+inline bool Expression_ReferenceSegment::has_reference_type() const {
+  return reference_type_case() != REFERENCE_TYPE_NOT_SET;
+}
+inline void Expression_ReferenceSegment::clear_has_reference_type() {
+  _oneof_case_[0] = REFERENCE_TYPE_NOT_SET;
+}
+inline Expression_ReferenceSegment::ReferenceTypeCase Expression_ReferenceSegment::reference_type_case() const {
+  return Expression_ReferenceSegment::ReferenceTypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Expression_MaskExpression_Select
+
+// .substrait.Expression.MaskExpression.StructSelect struct = 1;
+inline bool Expression_MaskExpression_Select::_internal_has_struct_() const {
+  return type_case() == kStruct;
+}
+inline bool Expression_MaskExpression_Select::has_struct_() const {
+  return _internal_has_struct_();
+}
+inline void Expression_MaskExpression_Select::set_has_struct_() {
+  _oneof_case_[0] = kStruct;
+}
+inline void Expression_MaskExpression_Select::clear_struct_() {
+  if (_internal_has_struct_()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete type_.struct__;
+    }
+    clear_has_type();
+  }
+}
+inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::release_struct_() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.Select.struct)
+  if (_internal_has_struct_()) {
+    clear_has_type();
+      ::substrait::Expression_MaskExpression_StructSelect* temp = type_.struct__;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    type_.struct__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression_Select::_internal_struct_() const {
+  return _internal_has_struct_()
+      ? *type_.struct__
+      : reinterpret_cast< ::substrait::Expression_MaskExpression_StructSelect&>(::substrait::_Expression_MaskExpression_StructSelect_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression_Select::struct_() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.Select.struct)
+  return _internal_struct_();
+}
+inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::unsafe_arena_release_struct_() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.Select.struct)
+  if (_internal_has_struct_()) {
+    clear_has_type();
+    ::substrait::Expression_MaskExpression_StructSelect* temp = type_.struct__;
+    type_.struct__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_struct_(::substrait::Expression_MaskExpression_StructSelect* struct_) {
+  clear_type();
+  if (struct_) {
+    set_has_struct_();
+    type_.struct__ = struct_;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.Select.struct)
+}
+inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::_internal_mutable_struct_() {
+  if (!_internal_has_struct_()) {
+    clear_type();
+    set_has_struct_();
+    type_.struct__ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructSelect >(GetArenaForAllocation());
+  }
+  return type_.struct__;
+}
+inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::mutable_struct_() {
+  ::substrait::Expression_MaskExpression_StructSelect* _msg = _internal_mutable_struct_();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.Select.struct)
+  return _msg;
+}
+
+// .substrait.Expression.MaskExpression.ListSelect list = 2;
+inline bool Expression_MaskExpression_Select::_internal_has_list() const {
+  return type_case() == kList;
+}
+inline bool Expression_MaskExpression_Select::has_list() const {
+  return _internal_has_list();
+}
+inline void Expression_MaskExpression_Select::set_has_list() {
+  _oneof_case_[0] = kList;
+}
+inline void Expression_MaskExpression_Select::clear_list() {
+  if (_internal_has_list()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete type_.list_;
+    }
+    clear_has_type();
+  }
+}
+inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::release_list() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.Select.list)
+  if (_internal_has_list()) {
+    clear_has_type();
+      ::substrait::Expression_MaskExpression_ListSelect* temp = type_.list_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    type_.list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_MaskExpression_ListSelect& Expression_MaskExpression_Select::_internal_list() const {
+  return _internal_has_list()
+      ? *type_.list_
+      : reinterpret_cast< ::substrait::Expression_MaskExpression_ListSelect&>(::substrait::_Expression_MaskExpression_ListSelect_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression_ListSelect& Expression_MaskExpression_Select::list() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.Select.list)
+  return _internal_list();
+}
+inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::unsafe_arena_release_list() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.Select.list)
+  if (_internal_has_list()) {
+    clear_has_type();
+    ::substrait::Expression_MaskExpression_ListSelect* temp = type_.list_;
+    type_.list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_list(::substrait::Expression_MaskExpression_ListSelect* list) {
+  clear_type();
+  if (list) {
+    set_has_list();
+    type_.list_ = list;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.Select.list)
+}
+inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::_internal_mutable_list() {
+  if (!_internal_has_list()) {
+    clear_type();
+    set_has_list();
+    type_.list_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect >(GetArenaForAllocation());
+  }
+  return type_.list_;
+}
+inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::mutable_list() {
+  ::substrait::Expression_MaskExpression_ListSelect* _msg = _internal_mutable_list();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.Select.list)
+  return _msg;
+}
+
+// .substrait.Expression.MaskExpression.MapSelect map = 3;
+inline bool Expression_MaskExpression_Select::_internal_has_map() const {
+  return type_case() == kMap;
+}
+inline bool Expression_MaskExpression_Select::has_map() const {
+  return _internal_has_map();
+}
+inline void Expression_MaskExpression_Select::set_has_map() {
+  _oneof_case_[0] = kMap;
+}
+inline void Expression_MaskExpression_Select::clear_map() {
+  if (_internal_has_map()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete type_.map_;
+    }
+    clear_has_type();
+  }
+}
+inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::release_map() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.Select.map)
+  if (_internal_has_map()) {
+    clear_has_type();
+      ::substrait::Expression_MaskExpression_MapSelect* temp = type_.map_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    type_.map_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_MaskExpression_MapSelect& Expression_MaskExpression_Select::_internal_map() const {
+  return _internal_has_map()
+      ? *type_.map_
+      : reinterpret_cast< ::substrait::Expression_MaskExpression_MapSelect&>(::substrait::_Expression_MaskExpression_MapSelect_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression_MapSelect& Expression_MaskExpression_Select::map() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.Select.map)
+  return _internal_map();
+}
+inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::unsafe_arena_release_map() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.Select.map)
+  if (_internal_has_map()) {
+    clear_has_type();
+    ::substrait::Expression_MaskExpression_MapSelect* temp = type_.map_;
+    type_.map_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_map(::substrait::Expression_MaskExpression_MapSelect* map) {
+  clear_type();
+  if (map) {
+    set_has_map();
+    type_.map_ = map;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.Select.map)
+}
+inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::_internal_mutable_map() {
+  if (!_internal_has_map()) {
+    clear_type();
+    set_has_map();
+    type_.map_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect >(GetArenaForAllocation());
+  }
+  return type_.map_;
+}
+inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::mutable_map() {
+  ::substrait::Expression_MaskExpression_MapSelect* _msg = _internal_mutable_map();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.Select.map)
+  return _msg;
+}
+
+inline bool Expression_MaskExpression_Select::has_type() const {
+  return type_case() != TYPE_NOT_SET;
+}
+inline void Expression_MaskExpression_Select::clear_has_type() {
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+inline Expression_MaskExpression_Select::TypeCase Expression_MaskExpression_Select::type_case() const {
+  return Expression_MaskExpression_Select::TypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Expression_MaskExpression_StructSelect
+
+// repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1;
+inline int Expression_MaskExpression_StructSelect::_internal_struct_items_size() const {
+  return struct_items_.size();
+}
+inline int Expression_MaskExpression_StructSelect::struct_items_size() const {
+  return _internal_struct_items_size();
+}
+inline void Expression_MaskExpression_StructSelect::clear_struct_items() {
+  struct_items_.Clear();
+}
+inline ::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::mutable_struct_items(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.StructSelect.struct_items)
+  return struct_items_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >*
+Expression_MaskExpression_StructSelect::mutable_struct_items() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MaskExpression.StructSelect.struct_items)
+  return &struct_items_;
+}
+inline const ::substrait::Expression_MaskExpression_StructItem& Expression_MaskExpression_StructSelect::_internal_struct_items(int index) const {
+  return struct_items_.Get(index);
+}
+inline const ::substrait::Expression_MaskExpression_StructItem& Expression_MaskExpression_StructSelect::struct_items(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.StructSelect.struct_items)
+  return _internal_struct_items(index);
+}
+inline ::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::_internal_add_struct_items() {
+  return struct_items_.Add();
+}
+inline ::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::add_struct_items() {
+  ::substrait::Expression_MaskExpression_StructItem* _add = _internal_add_struct_items();
+  // @@protoc_insertion_point(field_add:substrait.Expression.MaskExpression.StructSelect.struct_items)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >&
+Expression_MaskExpression_StructSelect::struct_items() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.MaskExpression.StructSelect.struct_items)
+  return struct_items_;
+}
+
+// -------------------------------------------------------------------
+
+// Expression_MaskExpression_StructItem
+
+// int32 field = 1;
+inline void Expression_MaskExpression_StructItem::clear_field() {
+  field_ = 0;
+}
+inline int32_t Expression_MaskExpression_StructItem::_internal_field() const {
+  return field_;
+}
+inline int32_t Expression_MaskExpression_StructItem::field() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.StructItem.field)
+  return _internal_field();
+}
+inline void Expression_MaskExpression_StructItem::_internal_set_field(int32_t value) {
+  
+  field_ = value;
+}
+inline void Expression_MaskExpression_StructItem::set_field(int32_t value) {
+  _internal_set_field(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.StructItem.field)
+}
+
+// .substrait.Expression.MaskExpression.Select child = 2;
+inline bool Expression_MaskExpression_StructItem::_internal_has_child() const {
+  return this != internal_default_instance() && child_ != nullptr;
+}
+inline bool Expression_MaskExpression_StructItem::has_child() const {
+  return _internal_has_child();
+}
+inline void Expression_MaskExpression_StructItem::clear_child() {
+  if (GetArenaForAllocation() == nullptr && child_ != nullptr) {
+    delete child_;
+  }
+  child_ = nullptr;
+}
+inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_StructItem::_internal_child() const {
+  const ::substrait::Expression_MaskExpression_Select* p = child_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_MaskExpression_Select&>(
+      ::substrait::_Expression_MaskExpression_Select_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_StructItem::child() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.StructItem.child)
+  return _internal_child();
+}
+inline void Expression_MaskExpression_StructItem::unsafe_arena_set_allocated_child(
+    ::substrait::Expression_MaskExpression_Select* child) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_);
+  }
+  child_ = child;
+  if (child) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.StructItem.child)
+}
+inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::release_child() {
+  
+  ::substrait::Expression_MaskExpression_Select* temp = child_;
+  child_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::unsafe_arena_release_child() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.StructItem.child)
+  
+  ::substrait::Expression_MaskExpression_Select* temp = child_;
+  child_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::_internal_mutable_child() {
+  
+  if (child_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArenaForAllocation());
+    child_ = p;
+  }
+  return child_;
+}
+inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::mutable_child() {
+  ::substrait::Expression_MaskExpression_Select* _msg = _internal_mutable_child();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.StructItem.child)
+  return _msg;
+}
+inline void Expression_MaskExpression_StructItem::set_allocated_child(::substrait::Expression_MaskExpression_Select* child) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete child_;
+  }
+  if (child) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_Select>::GetOwningArena(child);
+    if (message_arena != submessage_arena) {
+      child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, child, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  child_ = child;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.StructItem.child)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_MaskExpression_ListSelect_ListSelectItem_ListElement
+
+// int32 field = 1;
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::clear_field() {
+  field_ = 0;
+}
+inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_field() const {
+  return field_;
+}
+inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::field() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement.field)
+  return _internal_field();
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_set_field(int32_t value) {
+  
+  field_ = value;
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::set_field(int32_t value) {
+  _internal_set_field(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement.field)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice
+
+// int32 start = 1;
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::clear_start() {
+  start_ = 0;
+}
+inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_start() const {
+  return start_;
+}
+inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::start() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.start)
+  return _internal_start();
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_start(int32_t value) {
+  
+  start_ = value;
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_start(int32_t value) {
+  _internal_set_start(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.start)
+}
+
+// int32 end = 2;
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::clear_end() {
+  end_ = 0;
+}
+inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_end() const {
+  return end_;
+}
+inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::end() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.end)
+  return _internal_end();
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_end(int32_t value) {
+  
+  end_ = value;
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_end(int32_t value) {
+  _internal_set_end(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.end)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_MaskExpression_ListSelect_ListSelectItem
+
+// .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1;
+inline bool Expression_MaskExpression_ListSelect_ListSelectItem::_internal_has_item() const {
+  return type_case() == kItem;
+}
+inline bool Expression_MaskExpression_ListSelect_ListSelectItem::has_item() const {
+  return _internal_has_item();
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem::set_has_item() {
+  _oneof_case_[0] = kItem;
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_item() {
+  if (_internal_has_item()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete type_.item_;
+    }
+    clear_has_type();
+  }
+}
+inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::release_item() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item)
+  if (_internal_has_item()) {
+    clear_has_type();
+      ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    type_.item_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& Expression_MaskExpression_ListSelect_ListSelectItem::_internal_item() const {
+  return _internal_has_item()
+      ? *type_.item_
+      : reinterpret_cast< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&>(::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& Expression_MaskExpression_ListSelect_ListSelectItem::item() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item)
+  return _internal_item();
+}
+inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_item() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item)
+  if (_internal_has_item()) {
+    clear_has_type();
+    ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_;
+    type_.item_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_item(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item) {
+  clear_type();
+  if (item) {
+    set_has_item();
+    type_.item_ = item;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item)
+}
+inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::_internal_mutable_item() {
+  if (!_internal_has_item()) {
+    clear_type();
+    set_has_item();
+    type_.item_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(GetArenaForAllocation());
+  }
+  return type_.item_;
+}
+inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::mutable_item() {
+  ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* _msg = _internal_mutable_item();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item)
+  return _msg;
+}
+
+// .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2;
+inline bool Expression_MaskExpression_ListSelect_ListSelectItem::_internal_has_slice() const {
+  return type_case() == kSlice;
+}
+inline bool Expression_MaskExpression_ListSelect_ListSelectItem::has_slice() const {
+  return _internal_has_slice();
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem::set_has_slice() {
+  _oneof_case_[0] = kSlice;
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_slice() {
+  if (_internal_has_slice()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete type_.slice_;
+    }
+    clear_has_type();
+  }
+}
+inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::release_slice() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice)
+  if (_internal_has_slice()) {
+    clear_has_type();
+      ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    type_.slice_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& Expression_MaskExpression_ListSelect_ListSelectItem::_internal_slice() const {
+  return _internal_has_slice()
+      ? *type_.slice_
+      : reinterpret_cast< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&>(::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& Expression_MaskExpression_ListSelect_ListSelectItem::slice() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice)
+  return _internal_slice();
+}
+inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_slice() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice)
+  if (_internal_has_slice()) {
+    clear_has_type();
+    ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_;
+    type_.slice_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_slice(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) {
+  clear_type();
+  if (slice) {
+    set_has_slice();
+    type_.slice_ = slice;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice)
+}
+inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::_internal_mutable_slice() {
+  if (!_internal_has_slice()) {
+    clear_type();
+    set_has_slice();
+    type_.slice_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(GetArenaForAllocation());
+  }
+  return type_.slice_;
+}
+inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::mutable_slice() {
+  ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* _msg = _internal_mutable_slice();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice)
+  return _msg;
+}
+
+inline bool Expression_MaskExpression_ListSelect_ListSelectItem::has_type() const {
+  return type_case() != TYPE_NOT_SET;
+}
+inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_has_type() {
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+inline Expression_MaskExpression_ListSelect_ListSelectItem::TypeCase Expression_MaskExpression_ListSelect_ListSelectItem::type_case() const {
+  return Expression_MaskExpression_ListSelect_ListSelectItem::TypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Expression_MaskExpression_ListSelect
+
+// repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1;
+inline int Expression_MaskExpression_ListSelect::_internal_selection_size() const {
+  return selection_.size();
+}
+inline int Expression_MaskExpression_ListSelect::selection_size() const {
+  return _internal_selection_size();
+}
+inline void Expression_MaskExpression_ListSelect::clear_selection() {
+  selection_.Clear();
+}
+inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::mutable_selection(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.selection)
+  return selection_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >*
+Expression_MaskExpression_ListSelect::mutable_selection() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MaskExpression.ListSelect.selection)
+  return &selection_;
+}
+inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& Expression_MaskExpression_ListSelect::_internal_selection(int index) const {
+  return selection_.Get(index);
+}
+inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& Expression_MaskExpression_ListSelect::selection(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.selection)
+  return _internal_selection(index);
+}
+inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::_internal_add_selection() {
+  return selection_.Add();
+}
+inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::add_selection() {
+  ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* _add = _internal_add_selection();
+  // @@protoc_insertion_point(field_add:substrait.Expression.MaskExpression.ListSelect.selection)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >&
+Expression_MaskExpression_ListSelect::selection() const {
+  // @@protoc_insertion_point(field_list:substrait.Expression.MaskExpression.ListSelect.selection)
+  return selection_;
+}
+
+// .substrait.Expression.MaskExpression.Select child = 2;
+inline bool Expression_MaskExpression_ListSelect::_internal_has_child() const {
+  return this != internal_default_instance() && child_ != nullptr;
+}
+inline bool Expression_MaskExpression_ListSelect::has_child() const {
+  return _internal_has_child();
+}
+inline void Expression_MaskExpression_ListSelect::clear_child() {
+  if (GetArenaForAllocation() == nullptr && child_ != nullptr) {
+    delete child_;
+  }
+  child_ = nullptr;
+}
+inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_ListSelect::_internal_child() const {
+  const ::substrait::Expression_MaskExpression_Select* p = child_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_MaskExpression_Select&>(
+      ::substrait::_Expression_MaskExpression_Select_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_ListSelect::child() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.child)
+  return _internal_child();
+}
+inline void Expression_MaskExpression_ListSelect::unsafe_arena_set_allocated_child(
+    ::substrait::Expression_MaskExpression_Select* child) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_);
+  }
+  child_ = child;
+  if (child) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.ListSelect.child)
+}
+inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::release_child() {
+  
+  ::substrait::Expression_MaskExpression_Select* temp = child_;
+  child_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::unsafe_arena_release_child() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.ListSelect.child)
+  
+  ::substrait::Expression_MaskExpression_Select* temp = child_;
+  child_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::_internal_mutable_child() {
+  
+  if (child_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArenaForAllocation());
+    child_ = p;
+  }
+  return child_;
+}
+inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::mutable_child() {
+  ::substrait::Expression_MaskExpression_Select* _msg = _internal_mutable_child();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.child)
+  return _msg;
+}
+inline void Expression_MaskExpression_ListSelect::set_allocated_child(::substrait::Expression_MaskExpression_Select* child) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete child_;
+  }
+  if (child) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_Select>::GetOwningArena(child);
+    if (message_arena != submessage_arena) {
+      child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, child, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  child_ = child;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.child)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_MaskExpression_MapSelect_MapKey
+
+// string map_key = 1;
+inline void Expression_MaskExpression_MapSelect_MapKey::clear_map_key() {
+  map_key_.ClearToEmpty();
+}
+inline const std::string& Expression_MaskExpression_MapSelect_MapKey::map_key() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key)
+  return _internal_map_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Expression_MaskExpression_MapSelect_MapKey::set_map_key(ArgT0&& arg0, ArgT... args) {
+ 
+ map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key)
+}
+inline std::string* Expression_MaskExpression_MapSelect_MapKey::mutable_map_key() {
+  std::string* _s = _internal_mutable_map_key();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key)
+  return _s;
+}
+inline const std::string& Expression_MaskExpression_MapSelect_MapKey::_internal_map_key() const {
+  return map_key_.Get();
+}
+inline void Expression_MaskExpression_MapSelect_MapKey::_internal_set_map_key(const std::string& value) {
+  
+  map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Expression_MaskExpression_MapSelect_MapKey::_internal_mutable_map_key() {
+  
+  return map_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Expression_MaskExpression_MapSelect_MapKey::release_map_key() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key)
+  return map_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void Expression_MaskExpression_MapSelect_MapKey::set_allocated_map_key(std::string* map_key) {
+  if (map_key != nullptr) {
+    
+  } else {
+    
+  }
+  map_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (map_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    map_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_MaskExpression_MapSelect_MapKeyExpression
+
+// string map_key_expression = 1;
+inline void Expression_MaskExpression_MapSelect_MapKeyExpression::clear_map_key_expression() {
+  map_key_expression_.ClearToEmpty();
+}
+inline const std::string& Expression_MaskExpression_MapSelect_MapKeyExpression::map_key_expression() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression)
+  return _internal_map_key_expression();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void Expression_MaskExpression_MapSelect_MapKeyExpression::set_map_key_expression(ArgT0&& arg0, ArgT... args) {
+ 
+ map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression)
+}
+inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::mutable_map_key_expression() {
+  std::string* _s = _internal_mutable_map_key_expression();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression)
+  return _s;
+}
+inline const std::string& Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_map_key_expression() const {
+  return map_key_expression_.Get();
+}
+inline void Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_set_map_key_expression(const std::string& value) {
+  
+  map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_mutable_map_key_expression() {
+  
+  return map_key_expression_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::release_map_key_expression() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression)
+  return map_key_expression_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void Expression_MaskExpression_MapSelect_MapKeyExpression::set_allocated_map_key_expression(std::string* map_key_expression) {
+  if (map_key_expression != nullptr) {
+    
+  } else {
+    
+  }
+  map_key_expression_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key_expression,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (map_key_expression_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    map_key_expression_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_MaskExpression_MapSelect
+
+// .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1;
+inline bool Expression_MaskExpression_MapSelect::_internal_has_key() const {
+  return select_case() == kKey;
+}
+inline bool Expression_MaskExpression_MapSelect::has_key() const {
+  return _internal_has_key();
+}
+inline void Expression_MaskExpression_MapSelect::set_has_key() {
+  _oneof_case_[0] = kKey;
+}
+inline void Expression_MaskExpression_MapSelect::clear_key() {
+  if (_internal_has_key()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete select_.key_;
+    }
+    clear_has_select();
+  }
+}
+inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::release_key() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.key)
+  if (_internal_has_key()) {
+    clear_has_select();
+      ::substrait::Expression_MaskExpression_MapSelect_MapKey* temp = select_.key_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    select_.key_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_MaskExpression_MapSelect_MapKey& Expression_MaskExpression_MapSelect::_internal_key() const {
+  return _internal_has_key()
+      ? *select_.key_
+      : reinterpret_cast< ::substrait::Expression_MaskExpression_MapSelect_MapKey&>(::substrait::_Expression_MaskExpression_MapSelect_MapKey_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression_MapSelect_MapKey& Expression_MaskExpression_MapSelect::key() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.key)
+  return _internal_key();
+}
+inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.MapSelect.key)
+  if (_internal_has_key()) {
+    clear_has_select();
+    ::substrait::Expression_MaskExpression_MapSelect_MapKey* temp = select_.key_;
+    select_.key_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_key(::substrait::Expression_MaskExpression_MapSelect_MapKey* key) {
+  clear_select();
+  if (key) {
+    set_has_key();
+    select_.key_ = key;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.MapSelect.key)
+}
+inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::_internal_mutable_key() {
+  if (!_internal_has_key()) {
+    clear_select();
+    set_has_key();
+    select_.key_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(GetArenaForAllocation());
+  }
+  return select_.key_;
+}
+inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::mutable_key() {
+  ::substrait::Expression_MaskExpression_MapSelect_MapKey* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.key)
+  return _msg;
+}
+
+// .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2;
+inline bool Expression_MaskExpression_MapSelect::_internal_has_expression() const {
+  return select_case() == kExpression;
+}
+inline bool Expression_MaskExpression_MapSelect::has_expression() const {
+  return _internal_has_expression();
+}
+inline void Expression_MaskExpression_MapSelect::set_has_expression() {
+  _oneof_case_[0] = kExpression;
+}
+inline void Expression_MaskExpression_MapSelect::clear_expression() {
+  if (_internal_has_expression()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete select_.expression_;
+    }
+    clear_has_select();
+  }
+}
+inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::release_expression() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.expression)
+  if (_internal_has_expression()) {
+    clear_has_select();
+      ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    select_.expression_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& Expression_MaskExpression_MapSelect::_internal_expression() const {
+  return _internal_has_expression()
+      ? *select_.expression_
+      : reinterpret_cast< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression&>(::substrait::_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& Expression_MaskExpression_MapSelect::expression() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.expression)
+  return _internal_expression();
+}
+inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::unsafe_arena_release_expression() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.MapSelect.expression)
+  if (_internal_has_expression()) {
+    clear_has_select();
+    ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_;
+    select_.expression_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_expression(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression) {
+  clear_select();
+  if (expression) {
+    set_has_expression();
+    select_.expression_ = expression;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.MapSelect.expression)
+}
+inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::_internal_mutable_expression() {
+  if (!_internal_has_expression()) {
+    clear_select();
+    set_has_expression();
+    select_.expression_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(GetArenaForAllocation());
+  }
+  return select_.expression_;
+}
+inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::mutable_expression() {
+  ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* _msg = _internal_mutable_expression();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.expression)
+  return _msg;
+}
+
+// .substrait.Expression.MaskExpression.Select child = 3;
+inline bool Expression_MaskExpression_MapSelect::_internal_has_child() const {
+  return this != internal_default_instance() && child_ != nullptr;
+}
+inline bool Expression_MaskExpression_MapSelect::has_child() const {
+  return _internal_has_child();
+}
+inline void Expression_MaskExpression_MapSelect::clear_child() {
+  if (GetArenaForAllocation() == nullptr && child_ != nullptr) {
+    delete child_;
+  }
+  child_ = nullptr;
+}
+inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_MapSelect::_internal_child() const {
+  const ::substrait::Expression_MaskExpression_Select* p = child_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_MaskExpression_Select&>(
+      ::substrait::_Expression_MaskExpression_Select_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_MapSelect::child() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.child)
+  return _internal_child();
+}
+inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_child(
+    ::substrait::Expression_MaskExpression_Select* child) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_);
+  }
+  child_ = child;
+  if (child) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.MapSelect.child)
+}
+inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::release_child() {
+  
+  ::substrait::Expression_MaskExpression_Select* temp = child_;
+  child_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::unsafe_arena_release_child() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.child)
+  
+  ::substrait::Expression_MaskExpression_Select* temp = child_;
+  child_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::_internal_mutable_child() {
+  
+  if (child_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArenaForAllocation());
+    child_ = p;
+  }
+  return child_;
+}
+inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::mutable_child() {
+  ::substrait::Expression_MaskExpression_Select* _msg = _internal_mutable_child();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.child)
+  return _msg;
+}
+inline void Expression_MaskExpression_MapSelect::set_allocated_child(::substrait::Expression_MaskExpression_Select* child) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete child_;
+  }
+  if (child) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_Select>::GetOwningArena(child);
+    if (message_arena != submessage_arena) {
+      child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, child, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  child_ = child;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.child)
+}
+
+inline bool Expression_MaskExpression_MapSelect::has_select() const {
+  return select_case() != SELECT_NOT_SET;
+}
+inline void Expression_MaskExpression_MapSelect::clear_has_select() {
+  _oneof_case_[0] = SELECT_NOT_SET;
+}
+inline Expression_MaskExpression_MapSelect::SelectCase Expression_MaskExpression_MapSelect::select_case() const {
+  return Expression_MaskExpression_MapSelect::SelectCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Expression_MaskExpression
+
+// .substrait.Expression.MaskExpression.StructSelect select = 1;
+inline bool Expression_MaskExpression::_internal_has_select() const {
+  return this != internal_default_instance() && select_ != nullptr;
+}
+inline bool Expression_MaskExpression::has_select() const {
+  return _internal_has_select();
+}
+inline void Expression_MaskExpression::clear_select() {
+  if (GetArenaForAllocation() == nullptr && select_ != nullptr) {
+    delete select_;
+  }
+  select_ = nullptr;
+}
+inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression::_internal_select() const {
+  const ::substrait::Expression_MaskExpression_StructSelect* p = select_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_MaskExpression_StructSelect&>(
+      ::substrait::_Expression_MaskExpression_StructSelect_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression::select() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.select)
+  return _internal_select();
+}
+inline void Expression_MaskExpression::unsafe_arena_set_allocated_select(
+    ::substrait::Expression_MaskExpression_StructSelect* select) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(select_);
+  }
+  select_ = select;
+  if (select) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.select)
+}
+inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::release_select() {
+  
+  ::substrait::Expression_MaskExpression_StructSelect* temp = select_;
+  select_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::unsafe_arena_release_select() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.select)
+  
+  ::substrait::Expression_MaskExpression_StructSelect* temp = select_;
+  select_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::_internal_mutable_select() {
+  
+  if (select_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_StructSelect>(GetArenaForAllocation());
+    select_ = p;
+  }
+  return select_;
+}
+inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::mutable_select() {
+  ::substrait::Expression_MaskExpression_StructSelect* _msg = _internal_mutable_select();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.select)
+  return _msg;
+}
+inline void Expression_MaskExpression::set_allocated_select(::substrait::Expression_MaskExpression_StructSelect* select) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete select_;
+  }
+  if (select) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_StructSelect>::GetOwningArena(select);
+    if (message_arena != submessage_arena) {
+      select = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, select, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  select_ = select;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.select)
+}
+
+// bool maintain_singular_struct = 2;
+inline void Expression_MaskExpression::clear_maintain_singular_struct() {
+  maintain_singular_struct_ = false;
+}
+inline bool Expression_MaskExpression::_internal_maintain_singular_struct() const {
+  return maintain_singular_struct_;
+}
+inline bool Expression_MaskExpression::maintain_singular_struct() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.maintain_singular_struct)
+  return _internal_maintain_singular_struct();
+}
+inline void Expression_MaskExpression::_internal_set_maintain_singular_struct(bool value) {
+  
+  maintain_singular_struct_ = value;
+}
+inline void Expression_MaskExpression::set_maintain_singular_struct(bool value) {
+  _internal_set_maintain_singular_struct(value);
+  // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.maintain_singular_struct)
+}
+
+// -------------------------------------------------------------------
+
+// Expression_FieldReference_RootReference
+
+// -------------------------------------------------------------------
+
+// Expression_FieldReference
+
+// .substrait.Expression.ReferenceSegment direct_reference = 1;
+inline bool Expression_FieldReference::_internal_has_direct_reference() const {
+  return reference_type_case() == kDirectReference;
+}
+inline bool Expression_FieldReference::has_direct_reference() const {
+  return _internal_has_direct_reference();
+}
+inline void Expression_FieldReference::set_has_direct_reference() {
+  _oneof_case_[0] = kDirectReference;
+}
+inline void Expression_FieldReference::clear_direct_reference() {
+  if (_internal_has_direct_reference()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete reference_type_.direct_reference_;
+    }
+    clear_has_reference_type();
+  }
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::release_direct_reference() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.FieldReference.direct_reference)
+  if (_internal_has_direct_reference()) {
+    clear_has_reference_type();
+      ::substrait::Expression_ReferenceSegment* temp = reference_type_.direct_reference_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    reference_type_.direct_reference_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_ReferenceSegment& Expression_FieldReference::_internal_direct_reference() const {
+  return _internal_has_direct_reference()
+      ? *reference_type_.direct_reference_
+      : reinterpret_cast< ::substrait::Expression_ReferenceSegment&>(::substrait::_Expression_ReferenceSegment_default_instance_);
+}
+inline const ::substrait::Expression_ReferenceSegment& Expression_FieldReference::direct_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.FieldReference.direct_reference)
+  return _internal_direct_reference();
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::unsafe_arena_release_direct_reference() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.FieldReference.direct_reference)
+  if (_internal_has_direct_reference()) {
+    clear_has_reference_type();
+    ::substrait::Expression_ReferenceSegment* temp = reference_type_.direct_reference_;
+    reference_type_.direct_reference_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_FieldReference::unsafe_arena_set_allocated_direct_reference(::substrait::Expression_ReferenceSegment* direct_reference) {
+  clear_reference_type();
+  if (direct_reference) {
+    set_has_direct_reference();
+    reference_type_.direct_reference_ = direct_reference;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.FieldReference.direct_reference)
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::_internal_mutable_direct_reference() {
+  if (!_internal_has_direct_reference()) {
+    clear_reference_type();
+    set_has_direct_reference();
+    reference_type_.direct_reference_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment >(GetArenaForAllocation());
+  }
+  return reference_type_.direct_reference_;
+}
+inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::mutable_direct_reference() {
+  ::substrait::Expression_ReferenceSegment* _msg = _internal_mutable_direct_reference();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.direct_reference)
+  return _msg;
+}
+
+// .substrait.Expression.MaskExpression masked_reference = 2;
+inline bool Expression_FieldReference::_internal_has_masked_reference() const {
+  return reference_type_case() == kMaskedReference;
+}
+inline bool Expression_FieldReference::has_masked_reference() const {
+  return _internal_has_masked_reference();
+}
+inline void Expression_FieldReference::set_has_masked_reference() {
+  _oneof_case_[0] = kMaskedReference;
+}
+inline void Expression_FieldReference::clear_masked_reference() {
+  if (_internal_has_masked_reference()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete reference_type_.masked_reference_;
+    }
+    clear_has_reference_type();
+  }
+}
+inline ::substrait::Expression_MaskExpression* Expression_FieldReference::release_masked_reference() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.FieldReference.masked_reference)
+  if (_internal_has_masked_reference()) {
+    clear_has_reference_type();
+      ::substrait::Expression_MaskExpression* temp = reference_type_.masked_reference_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    reference_type_.masked_reference_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_MaskExpression& Expression_FieldReference::_internal_masked_reference() const {
+  return _internal_has_masked_reference()
+      ? *reference_type_.masked_reference_
+      : reinterpret_cast< ::substrait::Expression_MaskExpression&>(::substrait::_Expression_MaskExpression_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression& Expression_FieldReference::masked_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.FieldReference.masked_reference)
+  return _internal_masked_reference();
+}
+inline ::substrait::Expression_MaskExpression* Expression_FieldReference::unsafe_arena_release_masked_reference() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.FieldReference.masked_reference)
+  if (_internal_has_masked_reference()) {
+    clear_has_reference_type();
+    ::substrait::Expression_MaskExpression* temp = reference_type_.masked_reference_;
+    reference_type_.masked_reference_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_FieldReference::unsafe_arena_set_allocated_masked_reference(::substrait::Expression_MaskExpression* masked_reference) {
+  clear_reference_type();
+  if (masked_reference) {
+    set_has_masked_reference();
+    reference_type_.masked_reference_ = masked_reference;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.FieldReference.masked_reference)
+}
+inline ::substrait::Expression_MaskExpression* Expression_FieldReference::_internal_mutable_masked_reference() {
+  if (!_internal_has_masked_reference()) {
+    clear_reference_type();
+    set_has_masked_reference();
+    reference_type_.masked_reference_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression >(GetArenaForAllocation());
+  }
+  return reference_type_.masked_reference_;
+}
+inline ::substrait::Expression_MaskExpression* Expression_FieldReference::mutable_masked_reference() {
+  ::substrait::Expression_MaskExpression* _msg = _internal_mutable_masked_reference();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.masked_reference)
+  return _msg;
+}
+
+// .substrait.Expression expression = 3;
+inline bool Expression_FieldReference::_internal_has_expression() const {
+  return root_type_case() == kExpression;
+}
+inline bool Expression_FieldReference::has_expression() const {
+  return _internal_has_expression();
+}
+inline void Expression_FieldReference::set_has_expression() {
+  _oneof_case_[1] = kExpression;
+}
+inline void Expression_FieldReference::clear_expression() {
+  if (_internal_has_expression()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete root_type_.expression_;
+    }
+    clear_has_root_type();
+  }
+}
+inline ::substrait::Expression* Expression_FieldReference::release_expression() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.FieldReference.expression)
+  if (_internal_has_expression()) {
+    clear_has_root_type();
+      ::substrait::Expression* temp = root_type_.expression_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    root_type_.expression_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression& Expression_FieldReference::_internal_expression() const {
+  return _internal_has_expression()
+      ? *root_type_.expression_
+      : reinterpret_cast< ::substrait::Expression&>(::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& Expression_FieldReference::expression() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.FieldReference.expression)
+  return _internal_expression();
+}
+inline ::substrait::Expression* Expression_FieldReference::unsafe_arena_release_expression() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.FieldReference.expression)
+  if (_internal_has_expression()) {
+    clear_has_root_type();
+    ::substrait::Expression* temp = root_type_.expression_;
+    root_type_.expression_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_FieldReference::unsafe_arena_set_allocated_expression(::substrait::Expression* expression) {
+  clear_root_type();
+  if (expression) {
+    set_has_expression();
+    root_type_.expression_ = expression;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.FieldReference.expression)
+}
+inline ::substrait::Expression* Expression_FieldReference::_internal_mutable_expression() {
+  if (!_internal_has_expression()) {
+    clear_root_type();
+    set_has_expression();
+    root_type_.expression_ = CreateMaybeMessage< ::substrait::Expression >(GetArenaForAllocation());
+  }
+  return root_type_.expression_;
+}
+inline ::substrait::Expression* Expression_FieldReference::mutable_expression() {
+  ::substrait::Expression* _msg = _internal_mutable_expression();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.expression)
+  return _msg;
+}
+
+// .substrait.Expression.FieldReference.RootReference root_reference = 4;
+inline bool Expression_FieldReference::_internal_has_root_reference() const {
+  return root_type_case() == kRootReference;
+}
+inline bool Expression_FieldReference::has_root_reference() const {
+  return _internal_has_root_reference();
+}
+inline void Expression_FieldReference::set_has_root_reference() {
+  _oneof_case_[1] = kRootReference;
+}
+inline void Expression_FieldReference::clear_root_reference() {
+  if (_internal_has_root_reference()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete root_type_.root_reference_;
+    }
+    clear_has_root_type();
+  }
+}
+inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::release_root_reference() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.FieldReference.root_reference)
+  if (_internal_has_root_reference()) {
+    clear_has_root_type();
+      ::substrait::Expression_FieldReference_RootReference* temp = root_type_.root_reference_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    root_type_.root_reference_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_FieldReference_RootReference& Expression_FieldReference::_internal_root_reference() const {
+  return _internal_has_root_reference()
+      ? *root_type_.root_reference_
+      : reinterpret_cast< ::substrait::Expression_FieldReference_RootReference&>(::substrait::_Expression_FieldReference_RootReference_default_instance_);
+}
+inline const ::substrait::Expression_FieldReference_RootReference& Expression_FieldReference::root_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.FieldReference.root_reference)
+  return _internal_root_reference();
+}
+inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::unsafe_arena_release_root_reference() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.FieldReference.root_reference)
+  if (_internal_has_root_reference()) {
+    clear_has_root_type();
+    ::substrait::Expression_FieldReference_RootReference* temp = root_type_.root_reference_;
+    root_type_.root_reference_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression_FieldReference::unsafe_arena_set_allocated_root_reference(::substrait::Expression_FieldReference_RootReference* root_reference) {
+  clear_root_type();
+  if (root_reference) {
+    set_has_root_reference();
+    root_type_.root_reference_ = root_reference;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.FieldReference.root_reference)
+}
+inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::_internal_mutable_root_reference() {
+  if (!_internal_has_root_reference()) {
+    clear_root_type();
+    set_has_root_reference();
+    root_type_.root_reference_ = CreateMaybeMessage< ::substrait::Expression_FieldReference_RootReference >(GetArenaForAllocation());
+  }
+  return root_type_.root_reference_;
+}
+inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::mutable_root_reference() {
+  ::substrait::Expression_FieldReference_RootReference* _msg = _internal_mutable_root_reference();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.root_reference)
+  return _msg;
+}
+
+inline bool Expression_FieldReference::has_reference_type() const {
+  return reference_type_case() != REFERENCE_TYPE_NOT_SET;
+}
+inline void Expression_FieldReference::clear_has_reference_type() {
+  _oneof_case_[0] = REFERENCE_TYPE_NOT_SET;
+}
+inline bool Expression_FieldReference::has_root_type() const {
+  return root_type_case() != ROOT_TYPE_NOT_SET;
+}
+inline void Expression_FieldReference::clear_has_root_type() {
+  _oneof_case_[1] = ROOT_TYPE_NOT_SET;
+}
+inline Expression_FieldReference::ReferenceTypeCase Expression_FieldReference::reference_type_case() const {
+  return Expression_FieldReference::ReferenceTypeCase(_oneof_case_[0]);
+}
+inline Expression_FieldReference::RootTypeCase Expression_FieldReference::root_type_case() const {
+  return Expression_FieldReference::RootTypeCase(_oneof_case_[1]);
+}
+// -------------------------------------------------------------------
+
+// Expression
+
+// .substrait.Expression.Literal literal = 1;
+inline bool Expression::_internal_has_literal() const {
+  return rex_type_case() == kLiteral;
+}
+inline bool Expression::has_literal() const {
+  return _internal_has_literal();
+}
+inline void Expression::set_has_literal() {
+  _oneof_case_[0] = kLiteral;
+}
+inline void Expression::clear_literal() {
+  if (_internal_has_literal()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rex_type_.literal_;
+    }
+    clear_has_rex_type();
+  }
+}
+inline ::substrait::Expression_Literal* Expression::release_literal() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.literal)
+  if (_internal_has_literal()) {
+    clear_has_rex_type();
+      ::substrait::Expression_Literal* temp = rex_type_.literal_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rex_type_.literal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_Literal& Expression::_internal_literal() const {
+  return _internal_has_literal()
+      ? *rex_type_.literal_
+      : reinterpret_cast< ::substrait::Expression_Literal&>(::substrait::_Expression_Literal_default_instance_);
+}
+inline const ::substrait::Expression_Literal& Expression::literal() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.literal)
+  return _internal_literal();
+}
+inline ::substrait::Expression_Literal* Expression::unsafe_arena_release_literal() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.literal)
+  if (_internal_has_literal()) {
+    clear_has_rex_type();
+    ::substrait::Expression_Literal* temp = rex_type_.literal_;
+    rex_type_.literal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression::unsafe_arena_set_allocated_literal(::substrait::Expression_Literal* literal) {
+  clear_rex_type();
+  if (literal) {
+    set_has_literal();
+    rex_type_.literal_ = literal;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.literal)
+}
+inline ::substrait::Expression_Literal* Expression::_internal_mutable_literal() {
+  if (!_internal_has_literal()) {
+    clear_rex_type();
+    set_has_literal();
+    rex_type_.literal_ = CreateMaybeMessage< ::substrait::Expression_Literal >(GetArenaForAllocation());
+  }
+  return rex_type_.literal_;
+}
+inline ::substrait::Expression_Literal* Expression::mutable_literal() {
+  ::substrait::Expression_Literal* _msg = _internal_mutable_literal();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.literal)
+  return _msg;
+}
+
+// .substrait.Expression.FieldReference selection = 2;
+inline bool Expression::_internal_has_selection() const {
+  return rex_type_case() == kSelection;
+}
+inline bool Expression::has_selection() const {
+  return _internal_has_selection();
+}
+inline void Expression::set_has_selection() {
+  _oneof_case_[0] = kSelection;
+}
+inline void Expression::clear_selection() {
+  if (_internal_has_selection()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rex_type_.selection_;
+    }
+    clear_has_rex_type();
+  }
+}
+inline ::substrait::Expression_FieldReference* Expression::release_selection() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.selection)
+  if (_internal_has_selection()) {
+    clear_has_rex_type();
+      ::substrait::Expression_FieldReference* temp = rex_type_.selection_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rex_type_.selection_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_FieldReference& Expression::_internal_selection() const {
+  return _internal_has_selection()
+      ? *rex_type_.selection_
+      : reinterpret_cast< ::substrait::Expression_FieldReference&>(::substrait::_Expression_FieldReference_default_instance_);
+}
+inline const ::substrait::Expression_FieldReference& Expression::selection() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.selection)
+  return _internal_selection();
+}
+inline ::substrait::Expression_FieldReference* Expression::unsafe_arena_release_selection() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.selection)
+  if (_internal_has_selection()) {
+    clear_has_rex_type();
+    ::substrait::Expression_FieldReference* temp = rex_type_.selection_;
+    rex_type_.selection_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression::unsafe_arena_set_allocated_selection(::substrait::Expression_FieldReference* selection) {
+  clear_rex_type();
+  if (selection) {
+    set_has_selection();
+    rex_type_.selection_ = selection;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.selection)
+}
+inline ::substrait::Expression_FieldReference* Expression::_internal_mutable_selection() {
+  if (!_internal_has_selection()) {
+    clear_rex_type();
+    set_has_selection();
+    rex_type_.selection_ = CreateMaybeMessage< ::substrait::Expression_FieldReference >(GetArenaForAllocation());
+  }
+  return rex_type_.selection_;
+}
+inline ::substrait::Expression_FieldReference* Expression::mutable_selection() {
+  ::substrait::Expression_FieldReference* _msg = _internal_mutable_selection();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.selection)
+  return _msg;
+}
+
+// .substrait.Expression.ScalarFunction scalar_function = 3;
+inline bool Expression::_internal_has_scalar_function() const {
+  return rex_type_case() == kScalarFunction;
+}
+inline bool Expression::has_scalar_function() const {
+  return _internal_has_scalar_function();
+}
+inline void Expression::set_has_scalar_function() {
+  _oneof_case_[0] = kScalarFunction;
+}
+inline void Expression::clear_scalar_function() {
+  if (_internal_has_scalar_function()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rex_type_.scalar_function_;
+    }
+    clear_has_rex_type();
+  }
+}
+inline ::substrait::Expression_ScalarFunction* Expression::release_scalar_function() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.scalar_function)
+  if (_internal_has_scalar_function()) {
+    clear_has_rex_type();
+      ::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rex_type_.scalar_function_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_ScalarFunction& Expression::_internal_scalar_function() const {
+  return _internal_has_scalar_function()
+      ? *rex_type_.scalar_function_
+      : reinterpret_cast< ::substrait::Expression_ScalarFunction&>(::substrait::_Expression_ScalarFunction_default_instance_);
+}
+inline const ::substrait::Expression_ScalarFunction& Expression::scalar_function() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.scalar_function)
+  return _internal_scalar_function();
+}
+inline ::substrait::Expression_ScalarFunction* Expression::unsafe_arena_release_scalar_function() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.scalar_function)
+  if (_internal_has_scalar_function()) {
+    clear_has_rex_type();
+    ::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_;
+    rex_type_.scalar_function_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression::unsafe_arena_set_allocated_scalar_function(::substrait::Expression_ScalarFunction* scalar_function) {
+  clear_rex_type();
+  if (scalar_function) {
+    set_has_scalar_function();
+    rex_type_.scalar_function_ = scalar_function;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.scalar_function)
+}
+inline ::substrait::Expression_ScalarFunction* Expression::_internal_mutable_scalar_function() {
+  if (!_internal_has_scalar_function()) {
+    clear_rex_type();
+    set_has_scalar_function();
+    rex_type_.scalar_function_ = CreateMaybeMessage< ::substrait::Expression_ScalarFunction >(GetArenaForAllocation());
+  }
+  return rex_type_.scalar_function_;
+}
+inline ::substrait::Expression_ScalarFunction* Expression::mutable_scalar_function() {
+  ::substrait::Expression_ScalarFunction* _msg = _internal_mutable_scalar_function();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.scalar_function)
+  return _msg;
+}
+
+// .substrait.Expression.WindowFunction window_function = 5;
+inline bool Expression::_internal_has_window_function() const {
+  return rex_type_case() == kWindowFunction;
+}
+inline bool Expression::has_window_function() const {
+  return _internal_has_window_function();
+}
+inline void Expression::set_has_window_function() {
+  _oneof_case_[0] = kWindowFunction;
+}
+inline void Expression::clear_window_function() {
+  if (_internal_has_window_function()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rex_type_.window_function_;
+    }
+    clear_has_rex_type();
+  }
+}
+inline ::substrait::Expression_WindowFunction* Expression::release_window_function() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.window_function)
+  if (_internal_has_window_function()) {
+    clear_has_rex_type();
+      ::substrait::Expression_WindowFunction* temp = rex_type_.window_function_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rex_type_.window_function_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_WindowFunction& Expression::_internal_window_function() const {
+  return _internal_has_window_function()
+      ? *rex_type_.window_function_
+      : reinterpret_cast< ::substrait::Expression_WindowFunction&>(::substrait::_Expression_WindowFunction_default_instance_);
+}
+inline const ::substrait::Expression_WindowFunction& Expression::window_function() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.window_function)
+  return _internal_window_function();
+}
+inline ::substrait::Expression_WindowFunction* Expression::unsafe_arena_release_window_function() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.window_function)
+  if (_internal_has_window_function()) {
+    clear_has_rex_type();
+    ::substrait::Expression_WindowFunction* temp = rex_type_.window_function_;
+    rex_type_.window_function_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression::unsafe_arena_set_allocated_window_function(::substrait::Expression_WindowFunction* window_function) {
+  clear_rex_type();
+  if (window_function) {
+    set_has_window_function();
+    rex_type_.window_function_ = window_function;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.window_function)
+}
+inline ::substrait::Expression_WindowFunction* Expression::_internal_mutable_window_function() {
+  if (!_internal_has_window_function()) {
+    clear_rex_type();
+    set_has_window_function();
+    rex_type_.window_function_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction >(GetArenaForAllocation());
+  }
+  return rex_type_.window_function_;
+}
+inline ::substrait::Expression_WindowFunction* Expression::mutable_window_function() {
+  ::substrait::Expression_WindowFunction* _msg = _internal_mutable_window_function();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.window_function)
+  return _msg;
+}
+
+// .substrait.Expression.IfThen if_then = 6;
+inline bool Expression::_internal_has_if_then() const {
+  return rex_type_case() == kIfThen;
+}
+inline bool Expression::has_if_then() const {
+  return _internal_has_if_then();
+}
+inline void Expression::set_has_if_then() {
+  _oneof_case_[0] = kIfThen;
+}
+inline void Expression::clear_if_then() {
+  if (_internal_has_if_then()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rex_type_.if_then_;
+    }
+    clear_has_rex_type();
+  }
+}
+inline ::substrait::Expression_IfThen* Expression::release_if_then() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.if_then)
+  if (_internal_has_if_then()) {
+    clear_has_rex_type();
+      ::substrait::Expression_IfThen* temp = rex_type_.if_then_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rex_type_.if_then_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_IfThen& Expression::_internal_if_then() const {
+  return _internal_has_if_then()
+      ? *rex_type_.if_then_
+      : reinterpret_cast< ::substrait::Expression_IfThen&>(::substrait::_Expression_IfThen_default_instance_);
+}
+inline const ::substrait::Expression_IfThen& Expression::if_then() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.if_then)
+  return _internal_if_then();
+}
+inline ::substrait::Expression_IfThen* Expression::unsafe_arena_release_if_then() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.if_then)
+  if (_internal_has_if_then()) {
+    clear_has_rex_type();
+    ::substrait::Expression_IfThen* temp = rex_type_.if_then_;
+    rex_type_.if_then_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression::unsafe_arena_set_allocated_if_then(::substrait::Expression_IfThen* if_then) {
+  clear_rex_type();
+  if (if_then) {
+    set_has_if_then();
+    rex_type_.if_then_ = if_then;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.if_then)
+}
+inline ::substrait::Expression_IfThen* Expression::_internal_mutable_if_then() {
+  if (!_internal_has_if_then()) {
+    clear_rex_type();
+    set_has_if_then();
+    rex_type_.if_then_ = CreateMaybeMessage< ::substrait::Expression_IfThen >(GetArenaForAllocation());
+  }
+  return rex_type_.if_then_;
+}
+inline ::substrait::Expression_IfThen* Expression::mutable_if_then() {
+  ::substrait::Expression_IfThen* _msg = _internal_mutable_if_then();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.if_then)
+  return _msg;
+}
+
+// .substrait.Expression.SwitchExpression switch_expression = 7;
+inline bool Expression::_internal_has_switch_expression() const {
+  return rex_type_case() == kSwitchExpression;
+}
+inline bool Expression::has_switch_expression() const {
+  return _internal_has_switch_expression();
+}
+inline void Expression::set_has_switch_expression() {
+  _oneof_case_[0] = kSwitchExpression;
+}
+inline void Expression::clear_switch_expression() {
+  if (_internal_has_switch_expression()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rex_type_.switch_expression_;
+    }
+    clear_has_rex_type();
+  }
+}
+inline ::substrait::Expression_SwitchExpression* Expression::release_switch_expression() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.switch_expression)
+  if (_internal_has_switch_expression()) {
+    clear_has_rex_type();
+      ::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rex_type_.switch_expression_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_SwitchExpression& Expression::_internal_switch_expression() const {
+  return _internal_has_switch_expression()
+      ? *rex_type_.switch_expression_
+      : reinterpret_cast< ::substrait::Expression_SwitchExpression&>(::substrait::_Expression_SwitchExpression_default_instance_);
+}
+inline const ::substrait::Expression_SwitchExpression& Expression::switch_expression() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.switch_expression)
+  return _internal_switch_expression();
+}
+inline ::substrait::Expression_SwitchExpression* Expression::unsafe_arena_release_switch_expression() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.switch_expression)
+  if (_internal_has_switch_expression()) {
+    clear_has_rex_type();
+    ::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_;
+    rex_type_.switch_expression_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression::unsafe_arena_set_allocated_switch_expression(::substrait::Expression_SwitchExpression* switch_expression) {
+  clear_rex_type();
+  if (switch_expression) {
+    set_has_switch_expression();
+    rex_type_.switch_expression_ = switch_expression;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.switch_expression)
+}
+inline ::substrait::Expression_SwitchExpression* Expression::_internal_mutable_switch_expression() {
+  if (!_internal_has_switch_expression()) {
+    clear_rex_type();
+    set_has_switch_expression();
+    rex_type_.switch_expression_ = CreateMaybeMessage< ::substrait::Expression_SwitchExpression >(GetArenaForAllocation());
+  }
+  return rex_type_.switch_expression_;
+}
+inline ::substrait::Expression_SwitchExpression* Expression::mutable_switch_expression() {
+  ::substrait::Expression_SwitchExpression* _msg = _internal_mutable_switch_expression();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.switch_expression)
+  return _msg;
+}
+
+// .substrait.Expression.SingularOrList singular_or_list = 8;
+inline bool Expression::_internal_has_singular_or_list() const {
+  return rex_type_case() == kSingularOrList;
+}
+inline bool Expression::has_singular_or_list() const {
+  return _internal_has_singular_or_list();
+}
+inline void Expression::set_has_singular_or_list() {
+  _oneof_case_[0] = kSingularOrList;
+}
+inline void Expression::clear_singular_or_list() {
+  if (_internal_has_singular_or_list()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rex_type_.singular_or_list_;
+    }
+    clear_has_rex_type();
+  }
+}
+inline ::substrait::Expression_SingularOrList* Expression::release_singular_or_list() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.singular_or_list)
+  if (_internal_has_singular_or_list()) {
+    clear_has_rex_type();
+      ::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rex_type_.singular_or_list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_SingularOrList& Expression::_internal_singular_or_list() const {
+  return _internal_has_singular_or_list()
+      ? *rex_type_.singular_or_list_
+      : reinterpret_cast< ::substrait::Expression_SingularOrList&>(::substrait::_Expression_SingularOrList_default_instance_);
+}
+inline const ::substrait::Expression_SingularOrList& Expression::singular_or_list() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.singular_or_list)
+  return _internal_singular_or_list();
+}
+inline ::substrait::Expression_SingularOrList* Expression::unsafe_arena_release_singular_or_list() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.singular_or_list)
+  if (_internal_has_singular_or_list()) {
+    clear_has_rex_type();
+    ::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_;
+    rex_type_.singular_or_list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression::unsafe_arena_set_allocated_singular_or_list(::substrait::Expression_SingularOrList* singular_or_list) {
+  clear_rex_type();
+  if (singular_or_list) {
+    set_has_singular_or_list();
+    rex_type_.singular_or_list_ = singular_or_list;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.singular_or_list)
+}
+inline ::substrait::Expression_SingularOrList* Expression::_internal_mutable_singular_or_list() {
+  if (!_internal_has_singular_or_list()) {
+    clear_rex_type();
+    set_has_singular_or_list();
+    rex_type_.singular_or_list_ = CreateMaybeMessage< ::substrait::Expression_SingularOrList >(GetArenaForAllocation());
+  }
+  return rex_type_.singular_or_list_;
+}
+inline ::substrait::Expression_SingularOrList* Expression::mutable_singular_or_list() {
+  ::substrait::Expression_SingularOrList* _msg = _internal_mutable_singular_or_list();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.singular_or_list)
+  return _msg;
+}
+
+// .substrait.Expression.MultiOrList multi_or_list = 9;
+inline bool Expression::_internal_has_multi_or_list() const {
+  return rex_type_case() == kMultiOrList;
+}
+inline bool Expression::has_multi_or_list() const {
+  return _internal_has_multi_or_list();
+}
+inline void Expression::set_has_multi_or_list() {
+  _oneof_case_[0] = kMultiOrList;
+}
+inline void Expression::clear_multi_or_list() {
+  if (_internal_has_multi_or_list()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rex_type_.multi_or_list_;
+    }
+    clear_has_rex_type();
+  }
+}
+inline ::substrait::Expression_MultiOrList* Expression::release_multi_or_list() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.multi_or_list)
+  if (_internal_has_multi_or_list()) {
+    clear_has_rex_type();
+      ::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rex_type_.multi_or_list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_MultiOrList& Expression::_internal_multi_or_list() const {
+  return _internal_has_multi_or_list()
+      ? *rex_type_.multi_or_list_
+      : reinterpret_cast< ::substrait::Expression_MultiOrList&>(::substrait::_Expression_MultiOrList_default_instance_);
+}
+inline const ::substrait::Expression_MultiOrList& Expression::multi_or_list() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.multi_or_list)
+  return _internal_multi_or_list();
+}
+inline ::substrait::Expression_MultiOrList* Expression::unsafe_arena_release_multi_or_list() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.multi_or_list)
+  if (_internal_has_multi_or_list()) {
+    clear_has_rex_type();
+    ::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_;
+    rex_type_.multi_or_list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression::unsafe_arena_set_allocated_multi_or_list(::substrait::Expression_MultiOrList* multi_or_list) {
+  clear_rex_type();
+  if (multi_or_list) {
+    set_has_multi_or_list();
+    rex_type_.multi_or_list_ = multi_or_list;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.multi_or_list)
+}
+inline ::substrait::Expression_MultiOrList* Expression::_internal_mutable_multi_or_list() {
+  if (!_internal_has_multi_or_list()) {
+    clear_rex_type();
+    set_has_multi_or_list();
+    rex_type_.multi_or_list_ = CreateMaybeMessage< ::substrait::Expression_MultiOrList >(GetArenaForAllocation());
+  }
+  return rex_type_.multi_or_list_;
+}
+inline ::substrait::Expression_MultiOrList* Expression::mutable_multi_or_list() {
+  ::substrait::Expression_MultiOrList* _msg = _internal_mutable_multi_or_list();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.multi_or_list)
+  return _msg;
+}
+
+// .substrait.Expression.Enum enum = 10;
+inline bool Expression::_internal_has_enum_() const {
+  return rex_type_case() == kEnum;
+}
+inline bool Expression::has_enum_() const {
+  return _internal_has_enum_();
+}
+inline void Expression::set_has_enum_() {
+  _oneof_case_[0] = kEnum;
+}
+inline void Expression::clear_enum_() {
+  if (_internal_has_enum_()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rex_type_.enum__;
+    }
+    clear_has_rex_type();
+  }
+}
+inline ::substrait::Expression_Enum* Expression::release_enum_() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.enum)
+  if (_internal_has_enum_()) {
+    clear_has_rex_type();
+      ::substrait::Expression_Enum* temp = rex_type_.enum__;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rex_type_.enum__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_Enum& Expression::_internal_enum_() const {
+  return _internal_has_enum_()
+      ? *rex_type_.enum__
+      : reinterpret_cast< ::substrait::Expression_Enum&>(::substrait::_Expression_Enum_default_instance_);
+}
+inline const ::substrait::Expression_Enum& Expression::enum_() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.enum)
+  return _internal_enum_();
+}
+inline ::substrait::Expression_Enum* Expression::unsafe_arena_release_enum_() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.enum)
+  if (_internal_has_enum_()) {
+    clear_has_rex_type();
+    ::substrait::Expression_Enum* temp = rex_type_.enum__;
+    rex_type_.enum__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression::unsafe_arena_set_allocated_enum_(::substrait::Expression_Enum* enum_) {
+  clear_rex_type();
+  if (enum_) {
+    set_has_enum_();
+    rex_type_.enum__ = enum_;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.enum)
+}
+inline ::substrait::Expression_Enum* Expression::_internal_mutable_enum_() {
+  if (!_internal_has_enum_()) {
+    clear_rex_type();
+    set_has_enum_();
+    rex_type_.enum__ = CreateMaybeMessage< ::substrait::Expression_Enum >(GetArenaForAllocation());
+  }
+  return rex_type_.enum__;
+}
+inline ::substrait::Expression_Enum* Expression::mutable_enum_() {
+  ::substrait::Expression_Enum* _msg = _internal_mutable_enum_();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.enum)
+  return _msg;
+}
+
+// .substrait.Expression.Cast cast = 11;
+inline bool Expression::_internal_has_cast() const {
+  return rex_type_case() == kCast;
+}
+inline bool Expression::has_cast() const {
+  return _internal_has_cast();
+}
+inline void Expression::set_has_cast() {
+  _oneof_case_[0] = kCast;
+}
+inline void Expression::clear_cast() {
+  if (_internal_has_cast()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rex_type_.cast_;
+    }
+    clear_has_rex_type();
+  }
+}
+inline ::substrait::Expression_Cast* Expression::release_cast() {
+  // @@protoc_insertion_point(field_release:substrait.Expression.cast)
+  if (_internal_has_cast()) {
+    clear_has_rex_type();
+      ::substrait::Expression_Cast* temp = rex_type_.cast_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rex_type_.cast_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Expression_Cast& Expression::_internal_cast() const {
+  return _internal_has_cast()
+      ? *rex_type_.cast_
+      : reinterpret_cast< ::substrait::Expression_Cast&>(::substrait::_Expression_Cast_default_instance_);
+}
+inline const ::substrait::Expression_Cast& Expression::cast() const {
+  // @@protoc_insertion_point(field_get:substrait.Expression.cast)
+  return _internal_cast();
+}
+inline ::substrait::Expression_Cast* Expression::unsafe_arena_release_cast() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.cast)
+  if (_internal_has_cast()) {
+    clear_has_rex_type();
+    ::substrait::Expression_Cast* temp = rex_type_.cast_;
+    rex_type_.cast_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Expression::unsafe_arena_set_allocated_cast(::substrait::Expression_Cast* cast) {
+  clear_rex_type();
+  if (cast) {
+    set_has_cast();
+    rex_type_.cast_ = cast;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.cast)
+}
+inline ::substrait::Expression_Cast* Expression::_internal_mutable_cast() {
+  if (!_internal_has_cast()) {
+    clear_rex_type();
+    set_has_cast();
+    rex_type_.cast_ = CreateMaybeMessage< ::substrait::Expression_Cast >(GetArenaForAllocation());
+  }
+  return rex_type_.cast_;
+}
+inline ::substrait::Expression_Cast* Expression::mutable_cast() {
+  ::substrait::Expression_Cast* _msg = _internal_mutable_cast();
+  // @@protoc_insertion_point(field_mutable:substrait.Expression.cast)
+  return _msg;
+}
+
+inline bool Expression::has_rex_type() const {
+  return rex_type_case() != REX_TYPE_NOT_SET;
+}
+inline void Expression::clear_has_rex_type() {
+  _oneof_case_[0] = REX_TYPE_NOT_SET;
+}
+inline Expression::RexTypeCase Expression::rex_type_case() const {
+  return Expression::RexTypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// SortField
+
+// .substrait.Expression expr = 1;
+inline bool SortField::_internal_has_expr() const {
+  return this != internal_default_instance() && expr_ != nullptr;
+}
+inline bool SortField::has_expr() const {
+  return _internal_has_expr();
+}
+inline void SortField::clear_expr() {
+  if (GetArenaForAllocation() == nullptr && expr_ != nullptr) {
+    delete expr_;
+  }
+  expr_ = nullptr;
+}
+inline const ::substrait::Expression& SortField::_internal_expr() const {
+  const ::substrait::Expression* p = expr_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& SortField::expr() const {
+  // @@protoc_insertion_point(field_get:substrait.SortField.expr)
+  return _internal_expr();
+}
+inline void SortField::unsafe_arena_set_allocated_expr(
+    ::substrait::Expression* expr) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_);
+  }
+  expr_ = expr;
+  if (expr) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SortField.expr)
+}
+inline ::substrait::Expression* SortField::release_expr() {
+  
+  ::substrait::Expression* temp = expr_;
+  expr_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* SortField::unsafe_arena_release_expr() {
+  // @@protoc_insertion_point(field_release:substrait.SortField.expr)
+  
+  ::substrait::Expression* temp = expr_;
+  expr_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* SortField::_internal_mutable_expr() {
+  
+  if (expr_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    expr_ = p;
+  }
+  return expr_;
+}
+inline ::substrait::Expression* SortField::mutable_expr() {
+  ::substrait::Expression* _msg = _internal_mutable_expr();
+  // @@protoc_insertion_point(field_mutable:substrait.SortField.expr)
+  return _msg;
+}
+inline void SortField::set_allocated_expr(::substrait::Expression* expr) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete expr_;
+  }
+  if (expr) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(expr);
+    if (message_arena != submessage_arena) {
+      expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, expr, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  expr_ = expr;
+  // @@protoc_insertion_point(field_set_allocated:substrait.SortField.expr)
+}
+
+// .substrait.SortField.SortDirection direction = 2;
+inline bool SortField::_internal_has_direction() const {
+  return sort_kind_case() == kDirection;
+}
+inline bool SortField::has_direction() const {
+  return _internal_has_direction();
+}
+inline void SortField::set_has_direction() {
+  _oneof_case_[0] = kDirection;
+}
+inline void SortField::clear_direction() {
+  if (_internal_has_direction()) {
+    sort_kind_.direction_ = 0;
+    clear_has_sort_kind();
+  }
+}
+inline ::substrait::SortField_SortDirection SortField::_internal_direction() const {
+  if (_internal_has_direction()) {
+    return static_cast< ::substrait::SortField_SortDirection >(sort_kind_.direction_);
+  }
+  return static_cast< ::substrait::SortField_SortDirection >(0);
+}
+inline ::substrait::SortField_SortDirection SortField::direction() const {
+  // @@protoc_insertion_point(field_get:substrait.SortField.direction)
+  return _internal_direction();
+}
+inline void SortField::_internal_set_direction(::substrait::SortField_SortDirection value) {
+  if (!_internal_has_direction()) {
+    clear_sort_kind();
+    set_has_direction();
+  }
+  sort_kind_.direction_ = value;
+}
+inline void SortField::set_direction(::substrait::SortField_SortDirection value) {
+  _internal_set_direction(value);
+  // @@protoc_insertion_point(field_set:substrait.SortField.direction)
+}
+
+// uint32 comparison_function_reference = 3;
+inline bool SortField::_internal_has_comparison_function_reference() const {
+  return sort_kind_case() == kComparisonFunctionReference;
+}
+inline bool SortField::has_comparison_function_reference() const {
+  return _internal_has_comparison_function_reference();
+}
+inline void SortField::set_has_comparison_function_reference() {
+  _oneof_case_[0] = kComparisonFunctionReference;
+}
+inline void SortField::clear_comparison_function_reference() {
+  if (_internal_has_comparison_function_reference()) {
+    sort_kind_.comparison_function_reference_ = 0u;
+    clear_has_sort_kind();
+  }
+}
+inline uint32_t SortField::_internal_comparison_function_reference() const {
+  if (_internal_has_comparison_function_reference()) {
+    return sort_kind_.comparison_function_reference_;
+  }
+  return 0u;
+}
+inline void SortField::_internal_set_comparison_function_reference(uint32_t value) {
+  if (!_internal_has_comparison_function_reference()) {
+    clear_sort_kind();
+    set_has_comparison_function_reference();
+  }
+  sort_kind_.comparison_function_reference_ = value;
+}
+inline uint32_t SortField::comparison_function_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.SortField.comparison_function_reference)
+  return _internal_comparison_function_reference();
+}
+inline void SortField::set_comparison_function_reference(uint32_t value) {
+  _internal_set_comparison_function_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.SortField.comparison_function_reference)
+}
+
+inline bool SortField::has_sort_kind() const {
+  return sort_kind_case() != SORT_KIND_NOT_SET;
+}
+inline void SortField::clear_has_sort_kind() {
+  _oneof_case_[0] = SORT_KIND_NOT_SET;
+}
+inline SortField::SortKindCase SortField::sort_kind_case() const {
+  return SortField::SortKindCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// AggregateFunction
+
+// uint32 function_reference = 1;
+inline void AggregateFunction::clear_function_reference() {
+  function_reference_ = 0u;
+}
+inline uint32_t AggregateFunction::_internal_function_reference() const {
+  return function_reference_;
+}
+inline uint32_t AggregateFunction::function_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateFunction.function_reference)
+  return _internal_function_reference();
+}
+inline void AggregateFunction::_internal_set_function_reference(uint32_t value) {
+  
+  function_reference_ = value;
+}
+inline void AggregateFunction::set_function_reference(uint32_t value) {
+  _internal_set_function_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.AggregateFunction.function_reference)
+}
+
+// repeated .substrait.Expression args = 2;
+inline int AggregateFunction::_internal_args_size() const {
+  return args_.size();
+}
+inline int AggregateFunction::args_size() const {
+  return _internal_args_size();
+}
+inline void AggregateFunction::clear_args() {
+  args_.Clear();
+}
+inline ::substrait::Expression* AggregateFunction::mutable_args(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.AggregateFunction.args)
+  return args_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+AggregateFunction::mutable_args() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.AggregateFunction.args)
+  return &args_;
+}
+inline const ::substrait::Expression& AggregateFunction::_internal_args(int index) const {
+  return args_.Get(index);
+}
+inline const ::substrait::Expression& AggregateFunction::args(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateFunction.args)
+  return _internal_args(index);
+}
+inline ::substrait::Expression* AggregateFunction::_internal_add_args() {
+  return args_.Add();
+}
+inline ::substrait::Expression* AggregateFunction::add_args() {
+  ::substrait::Expression* _add = _internal_add_args();
+  // @@protoc_insertion_point(field_add:substrait.AggregateFunction.args)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+AggregateFunction::args() const {
+  // @@protoc_insertion_point(field_list:substrait.AggregateFunction.args)
+  return args_;
+}
+
+// repeated .substrait.SortField sorts = 3;
+inline int AggregateFunction::_internal_sorts_size() const {
+  return sorts_.size();
+}
+inline int AggregateFunction::sorts_size() const {
+  return _internal_sorts_size();
+}
+inline void AggregateFunction::clear_sorts() {
+  sorts_.Clear();
+}
+inline ::substrait::SortField* AggregateFunction::mutable_sorts(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.AggregateFunction.sorts)
+  return sorts_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >*
+AggregateFunction::mutable_sorts() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.AggregateFunction.sorts)
+  return &sorts_;
+}
+inline const ::substrait::SortField& AggregateFunction::_internal_sorts(int index) const {
+  return sorts_.Get(index);
+}
+inline const ::substrait::SortField& AggregateFunction::sorts(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateFunction.sorts)
+  return _internal_sorts(index);
+}
+inline ::substrait::SortField* AggregateFunction::_internal_add_sorts() {
+  return sorts_.Add();
+}
+inline ::substrait::SortField* AggregateFunction::add_sorts() {
+  ::substrait::SortField* _add = _internal_add_sorts();
+  // @@protoc_insertion_point(field_add:substrait.AggregateFunction.sorts)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >&
+AggregateFunction::sorts() const {
+  // @@protoc_insertion_point(field_list:substrait.AggregateFunction.sorts)
+  return sorts_;
+}
+
+// .substrait.AggregationPhase phase = 4;
+inline void AggregateFunction::clear_phase() {
+  phase_ = 0;
+}
+inline ::substrait::AggregationPhase AggregateFunction::_internal_phase() const {
+  return static_cast< ::substrait::AggregationPhase >(phase_);
+}
+inline ::substrait::AggregationPhase AggregateFunction::phase() const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateFunction.phase)
+  return _internal_phase();
+}
+inline void AggregateFunction::_internal_set_phase(::substrait::AggregationPhase value) {
+  
+  phase_ = value;
+}
+inline void AggregateFunction::set_phase(::substrait::AggregationPhase value) {
+  _internal_set_phase(value);
+  // @@protoc_insertion_point(field_set:substrait.AggregateFunction.phase)
+}
+
+// .substrait.Type output_type = 5;
+inline bool AggregateFunction::_internal_has_output_type() const {
+  return this != internal_default_instance() && output_type_ != nullptr;
+}
+inline bool AggregateFunction::has_output_type() const {
+  return _internal_has_output_type();
+}
+inline const ::substrait::Type& AggregateFunction::_internal_output_type() const {
+  const ::substrait::Type* p = output_type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Type&>(
+      ::substrait::_Type_default_instance_);
+}
+inline const ::substrait::Type& AggregateFunction::output_type() const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateFunction.output_type)
+  return _internal_output_type();
+}
+inline void AggregateFunction::unsafe_arena_set_allocated_output_type(
+    ::substrait::Type* output_type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  output_type_ = output_type;
+  if (output_type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateFunction.output_type)
+}
+inline ::substrait::Type* AggregateFunction::release_output_type() {
+  
+  ::substrait::Type* temp = output_type_;
+  output_type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Type* AggregateFunction::unsafe_arena_release_output_type() {
+  // @@protoc_insertion_point(field_release:substrait.AggregateFunction.output_type)
+  
+  ::substrait::Type* temp = output_type_;
+  output_type_ = nullptr;
+  return temp;
+}
+inline ::substrait::Type* AggregateFunction::_internal_mutable_output_type() {
+  
+  if (output_type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation());
+    output_type_ = p;
+  }
+  return output_type_;
+}
+inline ::substrait::Type* AggregateFunction::mutable_output_type() {
+  ::substrait::Type* _msg = _internal_mutable_output_type();
+  // @@protoc_insertion_point(field_mutable:substrait.AggregateFunction.output_type)
+  return _msg;
+}
+inline void AggregateFunction::set_allocated_output_type(::substrait::Type* output_type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  if (output_type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type));
+    if (message_arena != submessage_arena) {
+      output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, output_type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  output_type_ = output_type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.AggregateFunction.output_type)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace substrait
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::substrait::SortField_SortDirection> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::substrait::SortField_SortDirection>() {
+  return ::substrait::SortField_SortDirection_descriptor();
+}
+template <> struct is_proto_enum< ::substrait::AggregationPhase> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::substrait::AggregationPhase>() {
+  return ::substrait::AggregationPhase_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fexpression_2eproto
diff --git a/cpp/src/generated/substrait/extensions/extensions.pb.cc b/cpp/src/generated/substrait/extensions/extensions.pb.cc
new file mode 100644
index 000000000000..564fb8fb347c
--- /dev/null
+++ b/cpp/src/generated/substrait/extensions/extensions.pb.cc
@@ -0,0 +1,1881 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/extensions/extensions.proto
+
+#include "substrait/extensions/extensions.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace substrait {
+namespace extensions {
+constexpr SimpleExtensionURI::SimpleExtensionURI(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , extension_uri_anchor_(0u){}
+struct SimpleExtensionURIDefaultTypeInternal {
+  constexpr SimpleExtensionURIDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~SimpleExtensionURIDefaultTypeInternal() {}
+  union {
+    SimpleExtensionURI _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionURIDefaultTypeInternal _SimpleExtensionURI_default_instance_;
+constexpr SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , extension_uri_reference_(0u)
+  , type_anchor_(0u){}
+struct SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal {
+  constexpr SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal() {}
+  union {
+    SimpleExtensionDeclaration_ExtensionType _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionType_default_instance_;
+constexpr SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , extension_uri_reference_(0u)
+  , type_variation_anchor_(0u){}
+struct SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal {
+  constexpr SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal() {}
+  union {
+    SimpleExtensionDeclaration_ExtensionTypeVariation _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_;
+constexpr SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , extension_uri_reference_(0u)
+  , function_anchor_(0u){}
+struct SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal {
+  constexpr SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal() {}
+  union {
+    SimpleExtensionDeclaration_ExtensionFunction _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionFunction_default_instance_;
+constexpr SimpleExtensionDeclaration::SimpleExtensionDeclaration(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct SimpleExtensionDeclarationDefaultTypeInternal {
+  constexpr SimpleExtensionDeclarationDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~SimpleExtensionDeclarationDefaultTypeInternal() {}
+  union {
+    SimpleExtensionDeclaration _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclarationDefaultTypeInternal _SimpleExtensionDeclaration_default_instance_;
+constexpr AdvancedExtension::AdvancedExtension(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : optimization_(nullptr)
+  , enhancement_(nullptr){}
+struct AdvancedExtensionDefaultTypeInternal {
+  constexpr AdvancedExtensionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~AdvancedExtensionDefaultTypeInternal() {}
+  union {
+    AdvancedExtension _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AdvancedExtensionDefaultTypeInternal _AdvancedExtension_default_instance_;
+}  // namespace extensions
+}  // namespace substrait
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fextensions_2fextensions_2eproto[6];
+static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fextensions_2fextensions_2eproto = nullptr;
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fextensions_2fextensions_2eproto = nullptr;
+
+const uint32_t TableStruct_substrait_2fextensions_2fextensions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionURI, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionURI, extension_uri_anchor_),
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionURI, uri_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, extension_uri_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, type_anchor_),
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, name_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, extension_uri_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, type_variation_anchor_),
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, name_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, extension_uri_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, function_anchor_),
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, name_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration, mapping_type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::AdvancedExtension, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::AdvancedExtension, optimization_),
+  PROTOBUF_FIELD_OFFSET(::substrait::extensions::AdvancedExtension, enhancement_),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, -1, sizeof(::substrait::extensions::SimpleExtensionURI)},
+  { 8, -1, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType)},
+  { 17, -1, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation)},
+  { 26, -1, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction)},
+  { 35, -1, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration)},
+  { 45, -1, -1, sizeof(::substrait::extensions::AdvancedExtension)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::extensions::_SimpleExtensionURI_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::extensions::_SimpleExtensionDeclaration_ExtensionType_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::extensions::_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::extensions::_SimpleExtensionDeclaration_ExtensionFunction_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::extensions::_SimpleExtensionDeclaration_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::extensions::_AdvancedExtension_default_instance_),
+};
+
+const char descriptor_table_protodef_substrait_2fextensions_2fextensions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n%substrait/extensions/extensions.proto\022"
+  "\024substrait.extensions\032\031google/protobuf/a"
+  "ny.proto\"\?\n\022SimpleExtensionURI\022\034\n\024extens"
+  "ion_uri_anchor\030\001 \001(\r\022\013\n\003uri\030\002 \001(\t\"\357\004\n\032Si"
+  "mpleExtensionDeclaration\022X\n\016extension_ty"
+  "pe\030\001 \001(\0132>.substrait.extensions.SimpleEx"
+  "tensionDeclaration.ExtensionTypeH\000\022k\n\030ex"
+  "tension_type_variation\030\002 \001(\0132G.substrait"
+  ".extensions.SimpleExtensionDeclaration.E"
+  "xtensionTypeVariationH\000\022`\n\022extension_fun"
+  "ction\030\003 \001(\0132B.substrait.extensions.Simpl"
+  "eExtensionDeclaration.ExtensionFunctionH"
+  "\000\032S\n\rExtensionType\022\037\n\027extension_uri_refe"
+  "rence\030\001 \001(\r\022\023\n\013type_anchor\030\002 \001(\r\022\014\n\004name"
+  "\030\003 \001(\t\032f\n\026ExtensionTypeVariation\022\037\n\027exte"
+  "nsion_uri_reference\030\001 \001(\r\022\035\n\025type_variat"
+  "ion_anchor\030\002 \001(\r\022\014\n\004name\030\003 \001(\t\032[\n\021Extens"
+  "ionFunction\022\037\n\027extension_uri_reference\030\001"
+  " \001(\r\022\027\n\017function_anchor\030\002 \001(\r\022\014\n\004name\030\003 "
+  "\001(\tB\016\n\014mapping_type\"j\n\021AdvancedExtension"
+  "\022*\n\014optimization\030\001 \001(\0132\024.google.protobuf"
+  ".Any\022)\n\013enhancement\030\002 \001(\0132\024.google.proto"
+  "buf.AnyB+\n\022io.substrait.protoP\001\252\002\022Substr"
+  "ait.Protobufb\006proto3"
+  ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2fextensions_2fextensions_2eproto_deps[1] = {
+  &::descriptor_table_google_2fprotobuf_2fany_2eproto,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fextensions_2fextensions_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fextensions_2fextensions_2eproto = {
+  false, false, 940, descriptor_table_protodef_substrait_2fextensions_2fextensions_2eproto, "substrait/extensions/extensions.proto", 
+  &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, descriptor_table_substrait_2fextensions_2fextensions_2eproto_deps, 1, 6,
+  schemas, file_default_instances, TableStruct_substrait_2fextensions_2fextensions_2eproto::offsets,
+  file_level_metadata_substrait_2fextensions_2fextensions_2eproto, file_level_enum_descriptors_substrait_2fextensions_2fextensions_2eproto, file_level_service_descriptors_substrait_2fextensions_2fextensions_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter() {
+  return &descriptor_table_substrait_2fextensions_2fextensions_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fextensions_2fextensions_2eproto(&descriptor_table_substrait_2fextensions_2fextensions_2eproto);
+namespace substrait {
+namespace extensions {
+
+// ===================================================================
+
+class SimpleExtensionURI::_Internal {
+ public:
+};
+
+SimpleExtensionURI::SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionURI)
+}
+SimpleExtensionURI::SimpleExtensionURI(const SimpleExtensionURI& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_uri().empty()) {
+    uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), 
+      GetArenaForAllocation());
+  }
+  extension_uri_anchor_ = from.extension_uri_anchor_;
+  // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionURI)
+}
+
+inline void SimpleExtensionURI::SharedCtor() {
+uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+extension_uri_anchor_ = 0u;
+}
+
+SimpleExtensionURI::~SimpleExtensionURI() {
+  // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionURI)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void SimpleExtensionURI::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void SimpleExtensionURI::ArenaDtor(void* object) {
+  SimpleExtensionURI* _this = reinterpret_cast< SimpleExtensionURI* >(object);
+  (void)_this;
+}
+void SimpleExtensionURI::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void SimpleExtensionURI::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void SimpleExtensionURI::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionURI)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  uri_.ClearToEmpty();
+  extension_uri_anchor_ = 0u;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SimpleExtensionURI::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 extension_uri_anchor = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          extension_uri_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string uri = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_uri();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionURI.uri"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SimpleExtensionURI::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionURI)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 extension_uri_anchor = 1;
+  if (this->_internal_extension_uri_anchor() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_anchor(), target);
+  }
+
+  // string uri = 2;
+  if (!this->_internal_uri().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_uri().data(), static_cast<int>(this->_internal_uri().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.extensions.SimpleExtensionURI.uri");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_uri(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionURI)
+  return target;
+}
+
+size_t SimpleExtensionURI::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionURI)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string uri = 2;
+  if (!this->_internal_uri().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_uri());
+  }
+
+  // uint32 extension_uri_anchor = 1;
+  if (this->_internal_extension_uri_anchor() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_extension_uri_anchor());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionURI::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    SimpleExtensionURI::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionURI::GetClassData() const { return &_class_data_; }
+
+void SimpleExtensionURI::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<SimpleExtensionURI *>(to)->MergeFrom(
+      static_cast<const SimpleExtensionURI &>(from));
+}
+
+
+void SimpleExtensionURI::MergeFrom(const SimpleExtensionURI& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionURI)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_uri().empty()) {
+    _internal_set_uri(from._internal_uri());
+  }
+  if (from._internal_extension_uri_anchor() != 0) {
+    _internal_set_extension_uri_anchor(from._internal_extension_uri_anchor());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SimpleExtensionURI::CopyFrom(const SimpleExtensionURI& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionURI)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleExtensionURI::IsInitialized() const {
+  return true;
+}
+
+void SimpleExtensionURI::InternalSwap(SimpleExtensionURI* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &uri_, lhs_arena,
+      &other->uri_, rhs_arena
+  );
+  swap(extension_uri_anchor_, other->extension_uri_anchor_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionURI::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once,
+      file_level_metadata_substrait_2fextensions_2fextensions_2eproto[0]);
+}
+
+// ===================================================================
+
+class SimpleExtensionDeclaration_ExtensionType::_Internal {
+ public:
+};
+
+SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionType)
+}
+SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(const SimpleExtensionDeclaration_ExtensionType& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_name().empty()) {
+    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
+      GetArenaForAllocation());
+  }
+  ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&type_anchor_) -
+    reinterpret_cast<char*>(&extension_uri_reference_)) + sizeof(type_anchor_));
+  // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionType)
+}
+
+inline void SimpleExtensionDeclaration_ExtensionType::SharedCtor() {
+name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&extension_uri_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&type_anchor_) -
+    reinterpret_cast<char*>(&extension_uri_reference_)) + sizeof(type_anchor_));
+}
+
+SimpleExtensionDeclaration_ExtensionType::~SimpleExtensionDeclaration_ExtensionType() {
+  // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionType)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void SimpleExtensionDeclaration_ExtensionType::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void SimpleExtensionDeclaration_ExtensionType::ArenaDtor(void* object) {
+  SimpleExtensionDeclaration_ExtensionType* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionType* >(object);
+  (void)_this;
+}
+void SimpleExtensionDeclaration_ExtensionType::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void SimpleExtensionDeclaration_ExtensionType::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void SimpleExtensionDeclaration_ExtensionType::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  name_.ClearToEmpty();
+  ::memset(&extension_uri_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&type_anchor_) -
+      reinterpret_cast<char*>(&extension_uri_reference_)) + sizeof(type_anchor_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SimpleExtensionDeclaration_ExtensionType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 extension_uri_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 type_anchor = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          type_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string name = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_name();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SimpleExtensionDeclaration_ExtensionType::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 extension_uri_reference = 1;
+  if (this->_internal_extension_uri_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target);
+  }
+
+  // uint32 type_anchor = 2;
+  if (this->_internal_type_anchor() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_anchor(), target);
+  }
+
+  // string name = 3;
+  if (!this->_internal_name().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_name(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionDeclaration.ExtensionType)
+  return target;
+}
+
+size_t SimpleExtensionDeclaration_ExtensionType::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string name = 3;
+  if (!this->_internal_name().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  // uint32 extension_uri_reference = 1;
+  if (this->_internal_extension_uri_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_extension_uri_reference());
+  }
+
+  // uint32 type_anchor = 2;
+  if (this->_internal_type_anchor() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_anchor());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionDeclaration_ExtensionType::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    SimpleExtensionDeclaration_ExtensionType::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionDeclaration_ExtensionType::GetClassData() const { return &_class_data_; }
+
+void SimpleExtensionDeclaration_ExtensionType::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<SimpleExtensionDeclaration_ExtensionType *>(to)->MergeFrom(
+      static_cast<const SimpleExtensionDeclaration_ExtensionType &>(from));
+}
+
+
+void SimpleExtensionDeclaration_ExtensionType::MergeFrom(const SimpleExtensionDeclaration_ExtensionType& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_name().empty()) {
+    _internal_set_name(from._internal_name());
+  }
+  if (from._internal_extension_uri_reference() != 0) {
+    _internal_set_extension_uri_reference(from._internal_extension_uri_reference());
+  }
+  if (from._internal_type_anchor() != 0) {
+    _internal_set_type_anchor(from._internal_type_anchor());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SimpleExtensionDeclaration_ExtensionType::CopyFrom(const SimpleExtensionDeclaration_ExtensionType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleExtensionDeclaration_ExtensionType::IsInitialized() const {
+  return true;
+}
+
+void SimpleExtensionDeclaration_ExtensionType::InternalSwap(SimpleExtensionDeclaration_ExtensionType* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &name_, lhs_arena,
+      &other->name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionType, type_anchor_)
+      + sizeof(SimpleExtensionDeclaration_ExtensionType::type_anchor_)
+      - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionType, extension_uri_reference_)>(
+          reinterpret_cast<char*>(&extension_uri_reference_),
+          reinterpret_cast<char*>(&other->extension_uri_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionType::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once,
+      file_level_metadata_substrait_2fextensions_2fextensions_2eproto[1]);
+}
+
+// ===================================================================
+
+class SimpleExtensionDeclaration_ExtensionTypeVariation::_Internal {
+ public:
+};
+
+SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation)
+}
+SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(const SimpleExtensionDeclaration_ExtensionTypeVariation& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_name().empty()) {
+    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
+      GetArenaForAllocation());
+  }
+  ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&type_variation_anchor_) -
+    reinterpret_cast<char*>(&extension_uri_reference_)) + sizeof(type_variation_anchor_));
+  // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation)
+}
+
+inline void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedCtor() {
+name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&extension_uri_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&type_variation_anchor_) -
+    reinterpret_cast<char*>(&extension_uri_reference_)) + sizeof(type_variation_anchor_));
+}
+
+SimpleExtensionDeclaration_ExtensionTypeVariation::~SimpleExtensionDeclaration_ExtensionTypeVariation() {
+  // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void SimpleExtensionDeclaration_ExtensionTypeVariation::ArenaDtor(void* object) {
+  SimpleExtensionDeclaration_ExtensionTypeVariation* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionTypeVariation* >(object);
+  (void)_this;
+}
+void SimpleExtensionDeclaration_ExtensionTypeVariation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void SimpleExtensionDeclaration_ExtensionTypeVariation::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void SimpleExtensionDeclaration_ExtensionTypeVariation::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  name_.ClearToEmpty();
+  ::memset(&extension_uri_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&type_variation_anchor_) -
+      reinterpret_cast<char*>(&extension_uri_reference_)) + sizeof(type_variation_anchor_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 extension_uri_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 type_variation_anchor = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          type_variation_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string name = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_name();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 extension_uri_reference = 1;
+  if (this->_internal_extension_uri_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target);
+  }
+
+  // uint32 type_variation_anchor = 2;
+  if (this->_internal_type_variation_anchor() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_anchor(), target);
+  }
+
+  // string name = 3;
+  if (!this->_internal_name().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_name(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation)
+  return target;
+}
+
+size_t SimpleExtensionDeclaration_ExtensionTypeVariation::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string name = 3;
+  if (!this->_internal_name().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  // uint32 extension_uri_reference = 1;
+  if (this->_internal_extension_uri_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_extension_uri_reference());
+  }
+
+  // uint32 type_variation_anchor = 2;
+  if (this->_internal_type_variation_anchor() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_anchor());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionDeclaration_ExtensionTypeVariation::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    SimpleExtensionDeclaration_ExtensionTypeVariation::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionDeclaration_ExtensionTypeVariation::GetClassData() const { return &_class_data_; }
+
+void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<SimpleExtensionDeclaration_ExtensionTypeVariation *>(to)->MergeFrom(
+      static_cast<const SimpleExtensionDeclaration_ExtensionTypeVariation &>(from));
+}
+
+
+void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_name().empty()) {
+    _internal_set_name(from._internal_name());
+  }
+  if (from._internal_extension_uri_reference() != 0) {
+    _internal_set_extension_uri_reference(from._internal_extension_uri_reference());
+  }
+  if (from._internal_type_variation_anchor() != 0) {
+    _internal_set_type_variation_anchor(from._internal_type_variation_anchor());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SimpleExtensionDeclaration_ExtensionTypeVariation::CopyFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleExtensionDeclaration_ExtensionTypeVariation::IsInitialized() const {
+  return true;
+}
+
+void SimpleExtensionDeclaration_ExtensionTypeVariation::InternalSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &name_, lhs_arena,
+      &other->name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionTypeVariation, type_variation_anchor_)
+      + sizeof(SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor_)
+      - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionTypeVariation, extension_uri_reference_)>(
+          reinterpret_cast<char*>(&extension_uri_reference_),
+          reinterpret_cast<char*>(&other->extension_uri_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionTypeVariation::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once,
+      file_level_metadata_substrait_2fextensions_2fextensions_2eproto[2]);
+}
+
+// ===================================================================
+
+class SimpleExtensionDeclaration_ExtensionFunction::_Internal {
+ public:
+};
+
+SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction)
+}
+SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(const SimpleExtensionDeclaration_ExtensionFunction& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_name().empty()) {
+    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
+      GetArenaForAllocation());
+  }
+  ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&function_anchor_) -
+    reinterpret_cast<char*>(&extension_uri_reference_)) + sizeof(function_anchor_));
+  // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction)
+}
+
+inline void SimpleExtensionDeclaration_ExtensionFunction::SharedCtor() {
+name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&extension_uri_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&function_anchor_) -
+    reinterpret_cast<char*>(&extension_uri_reference_)) + sizeof(function_anchor_));
+}
+
+SimpleExtensionDeclaration_ExtensionFunction::~SimpleExtensionDeclaration_ExtensionFunction() {
+  // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void SimpleExtensionDeclaration_ExtensionFunction::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void SimpleExtensionDeclaration_ExtensionFunction::ArenaDtor(void* object) {
+  SimpleExtensionDeclaration_ExtensionFunction* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionFunction* >(object);
+  (void)_this;
+}
+void SimpleExtensionDeclaration_ExtensionFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void SimpleExtensionDeclaration_ExtensionFunction::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void SimpleExtensionDeclaration_ExtensionFunction::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  name_.ClearToEmpty();
+  ::memset(&extension_uri_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&function_anchor_) -
+      reinterpret_cast<char*>(&extension_uri_reference_)) + sizeof(function_anchor_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SimpleExtensionDeclaration_ExtensionFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 extension_uri_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 function_anchor = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          function_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string name = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_name();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SimpleExtensionDeclaration_ExtensionFunction::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 extension_uri_reference = 1;
+  if (this->_internal_extension_uri_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target);
+  }
+
+  // uint32 function_anchor = 2;
+  if (this->_internal_function_anchor() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_function_anchor(), target);
+  }
+
+  // string name = 3;
+  if (!this->_internal_name().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_name(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction)
+  return target;
+}
+
+size_t SimpleExtensionDeclaration_ExtensionFunction::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string name = 3;
+  if (!this->_internal_name().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  // uint32 extension_uri_reference = 1;
+  if (this->_internal_extension_uri_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_extension_uri_reference());
+  }
+
+  // uint32 function_anchor = 2;
+  if (this->_internal_function_anchor() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_anchor());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionDeclaration_ExtensionFunction::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    SimpleExtensionDeclaration_ExtensionFunction::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionDeclaration_ExtensionFunction::GetClassData() const { return &_class_data_; }
+
+void SimpleExtensionDeclaration_ExtensionFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<SimpleExtensionDeclaration_ExtensionFunction *>(to)->MergeFrom(
+      static_cast<const SimpleExtensionDeclaration_ExtensionFunction &>(from));
+}
+
+
+void SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(const SimpleExtensionDeclaration_ExtensionFunction& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_name().empty()) {
+    _internal_set_name(from._internal_name());
+  }
+  if (from._internal_extension_uri_reference() != 0) {
+    _internal_set_extension_uri_reference(from._internal_extension_uri_reference());
+  }
+  if (from._internal_function_anchor() != 0) {
+    _internal_set_function_anchor(from._internal_function_anchor());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SimpleExtensionDeclaration_ExtensionFunction::CopyFrom(const SimpleExtensionDeclaration_ExtensionFunction& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleExtensionDeclaration_ExtensionFunction::IsInitialized() const {
+  return true;
+}
+
+void SimpleExtensionDeclaration_ExtensionFunction::InternalSwap(SimpleExtensionDeclaration_ExtensionFunction* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &name_, lhs_arena,
+      &other->name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionFunction, function_anchor_)
+      + sizeof(SimpleExtensionDeclaration_ExtensionFunction::function_anchor_)
+      - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionFunction, extension_uri_reference_)>(
+          reinterpret_cast<char*>(&extension_uri_reference_),
+          reinterpret_cast<char*>(&other->extension_uri_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionFunction::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once,
+      file_level_metadata_substrait_2fextensions_2fextensions_2eproto[3]);
+}
+
+// ===================================================================
+
+class SimpleExtensionDeclaration::_Internal {
+ public:
+  static const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& extension_type(const SimpleExtensionDeclaration* msg);
+  static const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& extension_type_variation(const SimpleExtensionDeclaration* msg);
+  static const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& extension_function(const SimpleExtensionDeclaration* msg);
+};
+
+const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType&
+SimpleExtensionDeclaration::_Internal::extension_type(const SimpleExtensionDeclaration* msg) {
+  return *msg->mapping_type_.extension_type_;
+}
+const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation&
+SimpleExtensionDeclaration::_Internal::extension_type_variation(const SimpleExtensionDeclaration* msg) {
+  return *msg->mapping_type_.extension_type_variation_;
+}
+const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction&
+SimpleExtensionDeclaration::_Internal::extension_function(const SimpleExtensionDeclaration* msg) {
+  return *msg->mapping_type_.extension_function_;
+}
+void SimpleExtensionDeclaration::set_allocated_extension_type(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_mapping_type();
+  if (extension_type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::extensions::SimpleExtensionDeclaration_ExtensionType>::GetOwningArena(extension_type);
+    if (message_arena != submessage_arena) {
+      extension_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, extension_type, submessage_arena);
+    }
+    set_has_extension_type();
+    mapping_type_.extension_type_ = extension_type;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type)
+}
+void SimpleExtensionDeclaration::set_allocated_extension_type_variation(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_mapping_type();
+  if (extension_type_variation) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation>::GetOwningArena(extension_type_variation);
+    if (message_arena != submessage_arena) {
+      extension_type_variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, extension_type_variation, submessage_arena);
+    }
+    set_has_extension_type_variation();
+    mapping_type_.extension_type_variation_ = extension_type_variation;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation)
+}
+void SimpleExtensionDeclaration::set_allocated_extension_function(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_mapping_type();
+  if (extension_function) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction>::GetOwningArena(extension_function);
+    if (message_arena != submessage_arena) {
+      extension_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, extension_function, submessage_arena);
+    }
+    set_has_extension_function();
+    mapping_type_.extension_function_ = extension_function;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_function)
+}
+SimpleExtensionDeclaration::SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration)
+}
+SimpleExtensionDeclaration::SimpleExtensionDeclaration(const SimpleExtensionDeclaration& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_mapping_type();
+  switch (from.mapping_type_case()) {
+    case kExtensionType: {
+      _internal_mutable_extension_type()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionType::MergeFrom(from._internal_extension_type());
+      break;
+    }
+    case kExtensionTypeVariation: {
+      _internal_mutable_extension_type_variation()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(from._internal_extension_type_variation());
+      break;
+    }
+    case kExtensionFunction: {
+      _internal_mutable_extension_function()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(from._internal_extension_function());
+      break;
+    }
+    case MAPPING_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration)
+}
+
+inline void SimpleExtensionDeclaration::SharedCtor() {
+clear_has_mapping_type();
+}
+
+SimpleExtensionDeclaration::~SimpleExtensionDeclaration() {
+  // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void SimpleExtensionDeclaration::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_mapping_type()) {
+    clear_mapping_type();
+  }
+}
+
+void SimpleExtensionDeclaration::ArenaDtor(void* object) {
+  SimpleExtensionDeclaration* _this = reinterpret_cast< SimpleExtensionDeclaration* >(object);
+  (void)_this;
+}
+void SimpleExtensionDeclaration::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void SimpleExtensionDeclaration::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void SimpleExtensionDeclaration::clear_mapping_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.extensions.SimpleExtensionDeclaration)
+  switch (mapping_type_case()) {
+    case kExtensionType: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete mapping_type_.extension_type_;
+      }
+      break;
+    }
+    case kExtensionTypeVariation: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete mapping_type_.extension_type_variation_;
+      }
+      break;
+    }
+    case kExtensionFunction: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete mapping_type_.extension_function_;
+      }
+      break;
+    }
+    case MAPPING_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = MAPPING_TYPE_NOT_SET;
+}
+
+
+void SimpleExtensionDeclaration::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_mapping_type();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SimpleExtensionDeclaration::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_extension_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_extension_type_variation(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_extension_function(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SimpleExtensionDeclaration::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1;
+  if (_internal_has_extension_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::extension_type(this), target, stream);
+  }
+
+  // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2;
+  if (_internal_has_extension_type_variation()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::extension_type_variation(this), target, stream);
+  }
+
+  // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3;
+  if (_internal_has_extension_function()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::extension_function(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionDeclaration)
+  return target;
+}
+
+size_t SimpleExtensionDeclaration::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (mapping_type_case()) {
+    // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1;
+    case kExtensionType: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *mapping_type_.extension_type_);
+      break;
+    }
+    // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2;
+    case kExtensionTypeVariation: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *mapping_type_.extension_type_variation_);
+      break;
+    }
+    // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3;
+    case kExtensionFunction: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *mapping_type_.extension_function_);
+      break;
+    }
+    case MAPPING_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionDeclaration::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    SimpleExtensionDeclaration::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionDeclaration::GetClassData() const { return &_class_data_; }
+
+void SimpleExtensionDeclaration::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<SimpleExtensionDeclaration *>(to)->MergeFrom(
+      static_cast<const SimpleExtensionDeclaration &>(from));
+}
+
+
+void SimpleExtensionDeclaration::MergeFrom(const SimpleExtensionDeclaration& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.mapping_type_case()) {
+    case kExtensionType: {
+      _internal_mutable_extension_type()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionType::MergeFrom(from._internal_extension_type());
+      break;
+    }
+    case kExtensionTypeVariation: {
+      _internal_mutable_extension_type_variation()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(from._internal_extension_type_variation());
+      break;
+    }
+    case kExtensionFunction: {
+      _internal_mutable_extension_function()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(from._internal_extension_function());
+      break;
+    }
+    case MAPPING_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SimpleExtensionDeclaration::CopyFrom(const SimpleExtensionDeclaration& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionDeclaration)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SimpleExtensionDeclaration::IsInitialized() const {
+  return true;
+}
+
+void SimpleExtensionDeclaration::InternalSwap(SimpleExtensionDeclaration* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(mapping_type_, other->mapping_type_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once,
+      file_level_metadata_substrait_2fextensions_2fextensions_2eproto[4]);
+}
+
+// ===================================================================
+
+class AdvancedExtension::_Internal {
+ public:
+  static const ::PROTOBUF_NAMESPACE_ID::Any& optimization(const AdvancedExtension* msg);
+  static const ::PROTOBUF_NAMESPACE_ID::Any& enhancement(const AdvancedExtension* msg);
+};
+
+const ::PROTOBUF_NAMESPACE_ID::Any&
+AdvancedExtension::_Internal::optimization(const AdvancedExtension* msg) {
+  return *msg->optimization_;
+}
+const ::PROTOBUF_NAMESPACE_ID::Any&
+AdvancedExtension::_Internal::enhancement(const AdvancedExtension* msg) {
+  return *msg->enhancement_;
+}
+void AdvancedExtension::clear_optimization() {
+  if (GetArenaForAllocation() == nullptr && optimization_ != nullptr) {
+    delete optimization_;
+  }
+  optimization_ = nullptr;
+}
+void AdvancedExtension::clear_enhancement() {
+  if (GetArenaForAllocation() == nullptr && enhancement_ != nullptr) {
+    delete enhancement_;
+  }
+  enhancement_ = nullptr;
+}
+AdvancedExtension::AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.extensions.AdvancedExtension)
+}
+AdvancedExtension::AdvancedExtension(const AdvancedExtension& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_optimization()) {
+    optimization_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.optimization_);
+  } else {
+    optimization_ = nullptr;
+  }
+  if (from._internal_has_enhancement()) {
+    enhancement_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.enhancement_);
+  } else {
+    enhancement_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.extensions.AdvancedExtension)
+}
+
+inline void AdvancedExtension::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&optimization_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&enhancement_) -
+    reinterpret_cast<char*>(&optimization_)) + sizeof(enhancement_));
+}
+
+AdvancedExtension::~AdvancedExtension() {
+  // @@protoc_insertion_point(destructor:substrait.extensions.AdvancedExtension)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void AdvancedExtension::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete optimization_;
+  if (this != internal_default_instance()) delete enhancement_;
+}
+
+void AdvancedExtension::ArenaDtor(void* object) {
+  AdvancedExtension* _this = reinterpret_cast< AdvancedExtension* >(object);
+  (void)_this;
+}
+void AdvancedExtension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void AdvancedExtension::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void AdvancedExtension::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.extensions.AdvancedExtension)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && optimization_ != nullptr) {
+    delete optimization_;
+  }
+  optimization_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && enhancement_ != nullptr) {
+    delete enhancement_;
+  }
+  enhancement_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* AdvancedExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .google.protobuf.Any optimization = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_optimization(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .google.protobuf.Any enhancement = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_enhancement(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* AdvancedExtension::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.AdvancedExtension)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .google.protobuf.Any optimization = 1;
+  if (this->_internal_has_optimization()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::optimization(this), target, stream);
+  }
+
+  // .google.protobuf.Any enhancement = 2;
+  if (this->_internal_has_enhancement()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::enhancement(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.AdvancedExtension)
+  return target;
+}
+
+size_t AdvancedExtension::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.AdvancedExtension)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .google.protobuf.Any optimization = 1;
+  if (this->_internal_has_optimization()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *optimization_);
+  }
+
+  // .google.protobuf.Any enhancement = 2;
+  if (this->_internal_has_enhancement()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *enhancement_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AdvancedExtension::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    AdvancedExtension::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AdvancedExtension::GetClassData() const { return &_class_data_; }
+
+void AdvancedExtension::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<AdvancedExtension *>(to)->MergeFrom(
+      static_cast<const AdvancedExtension &>(from));
+}
+
+
+void AdvancedExtension::MergeFrom(const AdvancedExtension& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.AdvancedExtension)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_optimization()) {
+    _internal_mutable_optimization()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_optimization());
+  }
+  if (from._internal_has_enhancement()) {
+    _internal_mutable_enhancement()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_enhancement());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void AdvancedExtension::CopyFrom(const AdvancedExtension& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.AdvancedExtension)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AdvancedExtension::IsInitialized() const {
+  return true;
+}
+
+void AdvancedExtension::InternalSwap(AdvancedExtension* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(AdvancedExtension, enhancement_)
+      + sizeof(AdvancedExtension::enhancement_)
+      - PROTOBUF_FIELD_OFFSET(AdvancedExtension, optimization_)>(
+          reinterpret_cast<char*>(&optimization_),
+          reinterpret_cast<char*>(&other->optimization_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata AdvancedExtension::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once,
+      file_level_metadata_substrait_2fextensions_2fextensions_2eproto[5]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace extensions
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionURI* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionURI >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionURI >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionDeclaration* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionDeclaration >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::extensions::AdvancedExtension* Arena::CreateMaybeMessage< ::substrait::extensions::AdvancedExtension >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::extensions::AdvancedExtension >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/cpp/src/generated/substrait/extensions/extensions.pb.h b/cpp/src/generated/substrait/extensions/extensions.pb.h
new file mode 100644
index 000000000000..ee6e5499e61c
--- /dev/null
+++ b/cpp/src/generated/substrait/extensions/extensions.pb.h
@@ -0,0 +1,1966 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/extensions/extensions.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fextensions_2fextensions_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fextensions_2fextensions_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3019000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3019003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/any.pb.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_substrait_2fextensions_2fextensions_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_substrait_2fextensions_2fextensions_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fextensions_2fextensions_2eproto;
+namespace substrait {
+namespace extensions {
+class AdvancedExtension;
+struct AdvancedExtensionDefaultTypeInternal;
+extern AdvancedExtensionDefaultTypeInternal _AdvancedExtension_default_instance_;
+class SimpleExtensionDeclaration;
+struct SimpleExtensionDeclarationDefaultTypeInternal;
+extern SimpleExtensionDeclarationDefaultTypeInternal _SimpleExtensionDeclaration_default_instance_;
+class SimpleExtensionDeclaration_ExtensionFunction;
+struct SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal;
+extern SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionFunction_default_instance_;
+class SimpleExtensionDeclaration_ExtensionType;
+struct SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal;
+extern SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionType_default_instance_;
+class SimpleExtensionDeclaration_ExtensionTypeVariation;
+struct SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal;
+extern SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_;
+class SimpleExtensionURI;
+struct SimpleExtensionURIDefaultTypeInternal;
+extern SimpleExtensionURIDefaultTypeInternal _SimpleExtensionURI_default_instance_;
+}  // namespace extensions
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> ::substrait::extensions::AdvancedExtension* Arena::CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(Arena*);
+template<> ::substrait::extensions::SimpleExtensionDeclaration* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionDeclaration>(Arena*);
+template<> ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction>(Arena*);
+template<> ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionDeclaration_ExtensionType>(Arena*);
+template<> ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation>(Arena*);
+template<> ::substrait::extensions::SimpleExtensionURI* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionURI>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace substrait {
+namespace extensions {
+
+// ===================================================================
+
+class SimpleExtensionURI final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionURI) */ {
+ public:
+  inline SimpleExtensionURI() : SimpleExtensionURI(nullptr) {}
+  ~SimpleExtensionURI() override;
+  explicit constexpr SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SimpleExtensionURI(const SimpleExtensionURI& from);
+  SimpleExtensionURI(SimpleExtensionURI&& from) noexcept
+    : SimpleExtensionURI() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleExtensionURI& operator=(const SimpleExtensionURI& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SimpleExtensionURI& operator=(SimpleExtensionURI&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SimpleExtensionURI& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SimpleExtensionURI* internal_default_instance() {
+    return reinterpret_cast<const SimpleExtensionURI*>(
+               &_SimpleExtensionURI_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(SimpleExtensionURI& a, SimpleExtensionURI& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SimpleExtensionURI* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SimpleExtensionURI* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SimpleExtensionURI* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SimpleExtensionURI>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SimpleExtensionURI& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SimpleExtensionURI& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleExtensionURI* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.extensions.SimpleExtensionURI";
+  }
+  protected:
+  explicit SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUriFieldNumber = 2,
+    kExtensionUriAnchorFieldNumber = 1,
+  };
+  // string uri = 2;
+  void clear_uri();
+  const std::string& uri() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_uri(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_uri();
+  PROTOBUF_NODISCARD std::string* release_uri();
+  void set_allocated_uri(std::string* uri);
+  private:
+  const std::string& _internal_uri() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri(const std::string& value);
+  std::string* _internal_mutable_uri();
+  public:
+
+  // uint32 extension_uri_anchor = 1;
+  void clear_extension_uri_anchor();
+  uint32_t extension_uri_anchor() const;
+  void set_extension_uri_anchor(uint32_t value);
+  private:
+  uint32_t _internal_extension_uri_anchor() const;
+  void _internal_set_extension_uri_anchor(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionURI)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_;
+  uint32_t extension_uri_anchor_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SimpleExtensionDeclaration_ExtensionType final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) */ {
+ public:
+  inline SimpleExtensionDeclaration_ExtensionType() : SimpleExtensionDeclaration_ExtensionType(nullptr) {}
+  ~SimpleExtensionDeclaration_ExtensionType() override;
+  explicit constexpr SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SimpleExtensionDeclaration_ExtensionType(const SimpleExtensionDeclaration_ExtensionType& from);
+  SimpleExtensionDeclaration_ExtensionType(SimpleExtensionDeclaration_ExtensionType&& from) noexcept
+    : SimpleExtensionDeclaration_ExtensionType() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleExtensionDeclaration_ExtensionType& operator=(const SimpleExtensionDeclaration_ExtensionType& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SimpleExtensionDeclaration_ExtensionType& operator=(SimpleExtensionDeclaration_ExtensionType&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SimpleExtensionDeclaration_ExtensionType& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SimpleExtensionDeclaration_ExtensionType* internal_default_instance() {
+    return reinterpret_cast<const SimpleExtensionDeclaration_ExtensionType*>(
+               &_SimpleExtensionDeclaration_ExtensionType_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SimpleExtensionDeclaration_ExtensionType& a, SimpleExtensionDeclaration_ExtensionType& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SimpleExtensionDeclaration_ExtensionType* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionType* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SimpleExtensionDeclaration_ExtensionType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SimpleExtensionDeclaration_ExtensionType>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SimpleExtensionDeclaration_ExtensionType& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SimpleExtensionDeclaration_ExtensionType& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleExtensionDeclaration_ExtensionType* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.extensions.SimpleExtensionDeclaration.ExtensionType";
+  }
+  protected:
+  explicit SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 3,
+    kExtensionUriReferenceFieldNumber = 1,
+    kTypeAnchorFieldNumber = 2,
+  };
+  // string name = 3;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // uint32 extension_uri_reference = 1;
+  void clear_extension_uri_reference();
+  uint32_t extension_uri_reference() const;
+  void set_extension_uri_reference(uint32_t value);
+  private:
+  uint32_t _internal_extension_uri_reference() const;
+  void _internal_set_extension_uri_reference(uint32_t value);
+  public:
+
+  // uint32 type_anchor = 2;
+  void clear_type_anchor();
+  uint32_t type_anchor() const;
+  void set_type_anchor(uint32_t value);
+  private:
+  uint32_t _internal_type_anchor() const;
+  void _internal_set_type_anchor(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration.ExtensionType)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  uint32_t extension_uri_reference_;
+  uint32_t type_anchor_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SimpleExtensionDeclaration_ExtensionTypeVariation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) */ {
+ public:
+  inline SimpleExtensionDeclaration_ExtensionTypeVariation() : SimpleExtensionDeclaration_ExtensionTypeVariation(nullptr) {}
+  ~SimpleExtensionDeclaration_ExtensionTypeVariation() override;
+  explicit constexpr SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SimpleExtensionDeclaration_ExtensionTypeVariation(const SimpleExtensionDeclaration_ExtensionTypeVariation& from);
+  SimpleExtensionDeclaration_ExtensionTypeVariation(SimpleExtensionDeclaration_ExtensionTypeVariation&& from) noexcept
+    : SimpleExtensionDeclaration_ExtensionTypeVariation() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleExtensionDeclaration_ExtensionTypeVariation& operator=(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SimpleExtensionDeclaration_ExtensionTypeVariation& operator=(SimpleExtensionDeclaration_ExtensionTypeVariation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SimpleExtensionDeclaration_ExtensionTypeVariation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SimpleExtensionDeclaration_ExtensionTypeVariation* internal_default_instance() {
+    return reinterpret_cast<const SimpleExtensionDeclaration_ExtensionTypeVariation*>(
+               &_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(SimpleExtensionDeclaration_ExtensionTypeVariation& a, SimpleExtensionDeclaration_ExtensionTypeVariation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SimpleExtensionDeclaration_ExtensionTypeVariation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SimpleExtensionDeclaration_ExtensionTypeVariation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation";
+  }
+  protected:
+  explicit SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 3,
+    kExtensionUriReferenceFieldNumber = 1,
+    kTypeVariationAnchorFieldNumber = 2,
+  };
+  // string name = 3;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // uint32 extension_uri_reference = 1;
+  void clear_extension_uri_reference();
+  uint32_t extension_uri_reference() const;
+  void set_extension_uri_reference(uint32_t value);
+  private:
+  uint32_t _internal_extension_uri_reference() const;
+  void _internal_set_extension_uri_reference(uint32_t value);
+  public:
+
+  // uint32 type_variation_anchor = 2;
+  void clear_type_variation_anchor();
+  uint32_t type_variation_anchor() const;
+  void set_type_variation_anchor(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_anchor() const;
+  void _internal_set_type_variation_anchor(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  uint32_t extension_uri_reference_;
+  uint32_t type_variation_anchor_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SimpleExtensionDeclaration_ExtensionFunction final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) */ {
+ public:
+  inline SimpleExtensionDeclaration_ExtensionFunction() : SimpleExtensionDeclaration_ExtensionFunction(nullptr) {}
+  ~SimpleExtensionDeclaration_ExtensionFunction() override;
+  explicit constexpr SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SimpleExtensionDeclaration_ExtensionFunction(const SimpleExtensionDeclaration_ExtensionFunction& from);
+  SimpleExtensionDeclaration_ExtensionFunction(SimpleExtensionDeclaration_ExtensionFunction&& from) noexcept
+    : SimpleExtensionDeclaration_ExtensionFunction() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleExtensionDeclaration_ExtensionFunction& operator=(const SimpleExtensionDeclaration_ExtensionFunction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SimpleExtensionDeclaration_ExtensionFunction& operator=(SimpleExtensionDeclaration_ExtensionFunction&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SimpleExtensionDeclaration_ExtensionFunction& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SimpleExtensionDeclaration_ExtensionFunction* internal_default_instance() {
+    return reinterpret_cast<const SimpleExtensionDeclaration_ExtensionFunction*>(
+               &_SimpleExtensionDeclaration_ExtensionFunction_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(SimpleExtensionDeclaration_ExtensionFunction& a, SimpleExtensionDeclaration_ExtensionFunction& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SimpleExtensionDeclaration_ExtensionFunction* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionFunction* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SimpleExtensionDeclaration_ExtensionFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SimpleExtensionDeclaration_ExtensionFunction>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SimpleExtensionDeclaration_ExtensionFunction& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SimpleExtensionDeclaration_ExtensionFunction& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleExtensionDeclaration_ExtensionFunction* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction";
+  }
+  protected:
+  explicit SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 3,
+    kExtensionUriReferenceFieldNumber = 1,
+    kFunctionAnchorFieldNumber = 2,
+  };
+  // string name = 3;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // uint32 extension_uri_reference = 1;
+  void clear_extension_uri_reference();
+  uint32_t extension_uri_reference() const;
+  void set_extension_uri_reference(uint32_t value);
+  private:
+  uint32_t _internal_extension_uri_reference() const;
+  void _internal_set_extension_uri_reference(uint32_t value);
+  public:
+
+  // uint32 function_anchor = 2;
+  void clear_function_anchor();
+  uint32_t function_anchor() const;
+  void set_function_anchor(uint32_t value);
+  private:
+  uint32_t _internal_function_anchor() const;
+  void _internal_set_function_anchor(uint32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  uint32_t extension_uri_reference_;
+  uint32_t function_anchor_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SimpleExtensionDeclaration final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration) */ {
+ public:
+  inline SimpleExtensionDeclaration() : SimpleExtensionDeclaration(nullptr) {}
+  ~SimpleExtensionDeclaration() override;
+  explicit constexpr SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SimpleExtensionDeclaration(const SimpleExtensionDeclaration& from);
+  SimpleExtensionDeclaration(SimpleExtensionDeclaration&& from) noexcept
+    : SimpleExtensionDeclaration() {
+    *this = ::std::move(from);
+  }
+
+  inline SimpleExtensionDeclaration& operator=(const SimpleExtensionDeclaration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SimpleExtensionDeclaration& operator=(SimpleExtensionDeclaration&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SimpleExtensionDeclaration& default_instance() {
+    return *internal_default_instance();
+  }
+  enum MappingTypeCase {
+    kExtensionType = 1,
+    kExtensionTypeVariation = 2,
+    kExtensionFunction = 3,
+    MAPPING_TYPE_NOT_SET = 0,
+  };
+
+  static inline const SimpleExtensionDeclaration* internal_default_instance() {
+    return reinterpret_cast<const SimpleExtensionDeclaration*>(
+               &_SimpleExtensionDeclaration_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(SimpleExtensionDeclaration& a, SimpleExtensionDeclaration& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SimpleExtensionDeclaration* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SimpleExtensionDeclaration* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SimpleExtensionDeclaration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SimpleExtensionDeclaration>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SimpleExtensionDeclaration& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SimpleExtensionDeclaration& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SimpleExtensionDeclaration* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.extensions.SimpleExtensionDeclaration";
+  }
+  protected:
+  explicit SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SimpleExtensionDeclaration_ExtensionType ExtensionType;
+  typedef SimpleExtensionDeclaration_ExtensionTypeVariation ExtensionTypeVariation;
+  typedef SimpleExtensionDeclaration_ExtensionFunction ExtensionFunction;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kExtensionTypeFieldNumber = 1,
+    kExtensionTypeVariationFieldNumber = 2,
+    kExtensionFunctionFieldNumber = 3,
+  };
+  // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1;
+  bool has_extension_type() const;
+  private:
+  bool _internal_has_extension_type() const;
+  public:
+  void clear_extension_type();
+  const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& extension_type() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* release_extension_type();
+  ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* mutable_extension_type();
+  void set_allocated_extension_type(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type);
+  private:
+  const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& _internal_extension_type() const;
+  ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* _internal_mutable_extension_type();
+  public:
+  void unsafe_arena_set_allocated_extension_type(
+      ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type);
+  ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* unsafe_arena_release_extension_type();
+
+  // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2;
+  bool has_extension_type_variation() const;
+  private:
+  bool _internal_has_extension_type_variation() const;
+  public:
+  void clear_extension_type_variation();
+  const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& extension_type_variation() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* release_extension_type_variation();
+  ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* mutable_extension_type_variation();
+  void set_allocated_extension_type_variation(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation);
+  private:
+  const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& _internal_extension_type_variation() const;
+  ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* _internal_mutable_extension_type_variation();
+  public:
+  void unsafe_arena_set_allocated_extension_type_variation(
+      ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation);
+  ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* unsafe_arena_release_extension_type_variation();
+
+  // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3;
+  bool has_extension_function() const;
+  private:
+  bool _internal_has_extension_function() const;
+  public:
+  void clear_extension_function();
+  const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& extension_function() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* release_extension_function();
+  ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* mutable_extension_function();
+  void set_allocated_extension_function(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function);
+  private:
+  const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& _internal_extension_function() const;
+  ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* _internal_mutable_extension_function();
+  public:
+  void unsafe_arena_set_allocated_extension_function(
+      ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function);
+  ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* unsafe_arena_release_extension_function();
+
+  void clear_mapping_type();
+  MappingTypeCase mapping_type_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration)
+ private:
+  class _Internal;
+  void set_has_extension_type();
+  void set_has_extension_type_variation();
+  void set_has_extension_function();
+
+  inline bool has_mapping_type() const;
+  inline void clear_has_mapping_type();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union MappingTypeUnion {
+    constexpr MappingTypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type_;
+    ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation_;
+    ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function_;
+  } mapping_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AdvancedExtension final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.AdvancedExtension) */ {
+ public:
+  inline AdvancedExtension() : AdvancedExtension(nullptr) {}
+  ~AdvancedExtension() override;
+  explicit constexpr AdvancedExtension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AdvancedExtension(const AdvancedExtension& from);
+  AdvancedExtension(AdvancedExtension&& from) noexcept
+    : AdvancedExtension() {
+    *this = ::std::move(from);
+  }
+
+  inline AdvancedExtension& operator=(const AdvancedExtension& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AdvancedExtension& operator=(AdvancedExtension&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AdvancedExtension& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AdvancedExtension* internal_default_instance() {
+    return reinterpret_cast<const AdvancedExtension*>(
+               &_AdvancedExtension_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(AdvancedExtension& a, AdvancedExtension& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AdvancedExtension* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AdvancedExtension* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AdvancedExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AdvancedExtension>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AdvancedExtension& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const AdvancedExtension& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AdvancedExtension* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.extensions.AdvancedExtension";
+  }
+  protected:
+  explicit AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOptimizationFieldNumber = 1,
+    kEnhancementFieldNumber = 2,
+  };
+  // .google.protobuf.Any optimization = 1;
+  bool has_optimization() const;
+  private:
+  bool _internal_has_optimization() const;
+  public:
+  void clear_optimization();
+  const ::PROTOBUF_NAMESPACE_ID::Any& optimization() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_optimization();
+  ::PROTOBUF_NAMESPACE_ID::Any* mutable_optimization();
+  void set_allocated_optimization(::PROTOBUF_NAMESPACE_ID::Any* optimization);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_optimization() const;
+  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_optimization();
+  public:
+  void unsafe_arena_set_allocated_optimization(
+      ::PROTOBUF_NAMESPACE_ID::Any* optimization);
+  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_optimization();
+
+  // .google.protobuf.Any enhancement = 2;
+  bool has_enhancement() const;
+  private:
+  bool _internal_has_enhancement() const;
+  public:
+  void clear_enhancement();
+  const ::PROTOBUF_NAMESPACE_ID::Any& enhancement() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_enhancement();
+  ::PROTOBUF_NAMESPACE_ID::Any* mutable_enhancement();
+  void set_allocated_enhancement(::PROTOBUF_NAMESPACE_ID::Any* enhancement);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_enhancement() const;
+  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_enhancement();
+  public:
+  void unsafe_arena_set_allocated_enhancement(
+      ::PROTOBUF_NAMESPACE_ID::Any* enhancement);
+  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_enhancement();
+
+  // @@protoc_insertion_point(class_scope:substrait.extensions.AdvancedExtension)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::Any* optimization_;
+  ::PROTOBUF_NAMESPACE_ID::Any* enhancement_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SimpleExtensionURI
+
+// uint32 extension_uri_anchor = 1;
+inline void SimpleExtensionURI::clear_extension_uri_anchor() {
+  extension_uri_anchor_ = 0u;
+}
+inline uint32_t SimpleExtensionURI::_internal_extension_uri_anchor() const {
+  return extension_uri_anchor_;
+}
+inline uint32_t SimpleExtensionURI::extension_uri_anchor() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionURI.extension_uri_anchor)
+  return _internal_extension_uri_anchor();
+}
+inline void SimpleExtensionURI::_internal_set_extension_uri_anchor(uint32_t value) {
+  
+  extension_uri_anchor_ = value;
+}
+inline void SimpleExtensionURI::set_extension_uri_anchor(uint32_t value) {
+  _internal_set_extension_uri_anchor(value);
+  // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionURI.extension_uri_anchor)
+}
+
+// string uri = 2;
+inline void SimpleExtensionURI::clear_uri() {
+  uri_.ClearToEmpty();
+}
+inline const std::string& SimpleExtensionURI::uri() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionURI.uri)
+  return _internal_uri();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SimpleExtensionURI::set_uri(ArgT0&& arg0, ArgT... args) {
+ 
+ uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionURI.uri)
+}
+inline std::string* SimpleExtensionURI::mutable_uri() {
+  std::string* _s = _internal_mutable_uri();
+  // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionURI.uri)
+  return _s;
+}
+inline const std::string& SimpleExtensionURI::_internal_uri() const {
+  return uri_.Get();
+}
+inline void SimpleExtensionURI::_internal_set_uri(const std::string& value) {
+  
+  uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SimpleExtensionURI::_internal_mutable_uri() {
+  
+  return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SimpleExtensionURI::release_uri() {
+  // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionURI.uri)
+  return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SimpleExtensionURI::set_allocated_uri(std::string* uri) {
+  if (uri != nullptr) {
+    
+  } else {
+    
+  }
+  uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (uri_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionURI.uri)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleExtensionDeclaration_ExtensionType
+
+// uint32 extension_uri_reference = 1;
+inline void SimpleExtensionDeclaration_ExtensionType::clear_extension_uri_reference() {
+  extension_uri_reference_ = 0u;
+}
+inline uint32_t SimpleExtensionDeclaration_ExtensionType::_internal_extension_uri_reference() const {
+  return extension_uri_reference_;
+}
+inline uint32_t SimpleExtensionDeclaration_ExtensionType::extension_uri_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.extension_uri_reference)
+  return _internal_extension_uri_reference();
+}
+inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_extension_uri_reference(uint32_t value) {
+  
+  extension_uri_reference_ = value;
+}
+inline void SimpleExtensionDeclaration_ExtensionType::set_extension_uri_reference(uint32_t value) {
+  _internal_set_extension_uri_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.extension_uri_reference)
+}
+
+// uint32 type_anchor = 2;
+inline void SimpleExtensionDeclaration_ExtensionType::clear_type_anchor() {
+  type_anchor_ = 0u;
+}
+inline uint32_t SimpleExtensionDeclaration_ExtensionType::_internal_type_anchor() const {
+  return type_anchor_;
+}
+inline uint32_t SimpleExtensionDeclaration_ExtensionType::type_anchor() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.type_anchor)
+  return _internal_type_anchor();
+}
+inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_type_anchor(uint32_t value) {
+  
+  type_anchor_ = value;
+}
+inline void SimpleExtensionDeclaration_ExtensionType::set_type_anchor(uint32_t value) {
+  _internal_set_type_anchor(value);
+  // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.type_anchor)
+}
+
+// string name = 3;
+inline void SimpleExtensionDeclaration_ExtensionType::clear_name() {
+  name_.ClearToEmpty();
+}
+inline const std::string& SimpleExtensionDeclaration_ExtensionType::name() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SimpleExtensionDeclaration_ExtensionType::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name)
+}
+inline std::string* SimpleExtensionDeclaration_ExtensionType::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name)
+  return _s;
+}
+inline const std::string& SimpleExtensionDeclaration_ExtensionType::_internal_name() const {
+  return name_.Get();
+}
+inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_name(const std::string& value) {
+  
+  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SimpleExtensionDeclaration_ExtensionType::_internal_mutable_name() {
+  
+  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SimpleExtensionDeclaration_ExtensionType::release_name() {
+  // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name)
+  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SimpleExtensionDeclaration_ExtensionType::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleExtensionDeclaration_ExtensionTypeVariation
+
+// uint32 extension_uri_reference = 1;
+inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_extension_uri_reference() {
+  extension_uri_reference_ = 0u;
+}
+inline uint32_t SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_extension_uri_reference() const {
+  return extension_uri_reference_;
+}
+inline uint32_t SimpleExtensionDeclaration_ExtensionTypeVariation::extension_uri_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.extension_uri_reference)
+  return _internal_extension_uri_reference();
+}
+inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_extension_uri_reference(uint32_t value) {
+  
+  extension_uri_reference_ = value;
+}
+inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_extension_uri_reference(uint32_t value) {
+  _internal_set_extension_uri_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.extension_uri_reference)
+}
+
+// uint32 type_variation_anchor = 2;
+inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_type_variation_anchor() {
+  type_variation_anchor_ = 0u;
+}
+inline uint32_t SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_type_variation_anchor() const {
+  return type_variation_anchor_;
+}
+inline uint32_t SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.type_variation_anchor)
+  return _internal_type_variation_anchor();
+}
+inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_type_variation_anchor(uint32_t value) {
+  
+  type_variation_anchor_ = value;
+}
+inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_type_variation_anchor(uint32_t value) {
+  _internal_set_type_variation_anchor(value);
+  // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.type_variation_anchor)
+}
+
+// string name = 3;
+inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_name() {
+  name_.ClearToEmpty();
+}
+inline const std::string& SimpleExtensionDeclaration_ExtensionTypeVariation::name() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SimpleExtensionDeclaration_ExtensionTypeVariation::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name)
+}
+inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name)
+  return _s;
+}
+inline const std::string& SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_name() const {
+  return name_.Get();
+}
+inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_name(const std::string& value) {
+  
+  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_mutable_name() {
+  
+  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::release_name() {
+  // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name)
+  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleExtensionDeclaration_ExtensionFunction
+
+// uint32 extension_uri_reference = 1;
+inline void SimpleExtensionDeclaration_ExtensionFunction::clear_extension_uri_reference() {
+  extension_uri_reference_ = 0u;
+}
+inline uint32_t SimpleExtensionDeclaration_ExtensionFunction::_internal_extension_uri_reference() const {
+  return extension_uri_reference_;
+}
+inline uint32_t SimpleExtensionDeclaration_ExtensionFunction::extension_uri_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.extension_uri_reference)
+  return _internal_extension_uri_reference();
+}
+inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_extension_uri_reference(uint32_t value) {
+  
+  extension_uri_reference_ = value;
+}
+inline void SimpleExtensionDeclaration_ExtensionFunction::set_extension_uri_reference(uint32_t value) {
+  _internal_set_extension_uri_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.extension_uri_reference)
+}
+
+// uint32 function_anchor = 2;
+inline void SimpleExtensionDeclaration_ExtensionFunction::clear_function_anchor() {
+  function_anchor_ = 0u;
+}
+inline uint32_t SimpleExtensionDeclaration_ExtensionFunction::_internal_function_anchor() const {
+  return function_anchor_;
+}
+inline uint32_t SimpleExtensionDeclaration_ExtensionFunction::function_anchor() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.function_anchor)
+  return _internal_function_anchor();
+}
+inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_function_anchor(uint32_t value) {
+  
+  function_anchor_ = value;
+}
+inline void SimpleExtensionDeclaration_ExtensionFunction::set_function_anchor(uint32_t value) {
+  _internal_set_function_anchor(value);
+  // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.function_anchor)
+}
+
+// string name = 3;
+inline void SimpleExtensionDeclaration_ExtensionFunction::clear_name() {
+  name_.ClearToEmpty();
+}
+inline const std::string& SimpleExtensionDeclaration_ExtensionFunction::name() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SimpleExtensionDeclaration_ExtensionFunction::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name)
+}
+inline std::string* SimpleExtensionDeclaration_ExtensionFunction::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name)
+  return _s;
+}
+inline const std::string& SimpleExtensionDeclaration_ExtensionFunction::_internal_name() const {
+  return name_.Get();
+}
+inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_name(const std::string& value) {
+  
+  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SimpleExtensionDeclaration_ExtensionFunction::_internal_mutable_name() {
+  
+  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SimpleExtensionDeclaration_ExtensionFunction::release_name() {
+  // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name)
+  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SimpleExtensionDeclaration_ExtensionFunction::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name)
+}
+
+// -------------------------------------------------------------------
+
+// SimpleExtensionDeclaration
+
+// .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1;
+inline bool SimpleExtensionDeclaration::_internal_has_extension_type() const {
+  return mapping_type_case() == kExtensionType;
+}
+inline bool SimpleExtensionDeclaration::has_extension_type() const {
+  return _internal_has_extension_type();
+}
+inline void SimpleExtensionDeclaration::set_has_extension_type() {
+  _oneof_case_[0] = kExtensionType;
+}
+inline void SimpleExtensionDeclaration::clear_extension_type() {
+  if (_internal_has_extension_type()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete mapping_type_.extension_type_;
+    }
+    clear_has_mapping_type();
+  }
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::release_extension_type() {
+  // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.extension_type)
+  if (_internal_has_extension_type()) {
+    clear_has_mapping_type();
+      ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* temp = mapping_type_.extension_type_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    mapping_type_.extension_type_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& SimpleExtensionDeclaration::_internal_extension_type() const {
+  return _internal_has_extension_type()
+      ? *mapping_type_.extension_type_
+      : reinterpret_cast< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType&>(::substrait::extensions::_SimpleExtensionDeclaration_ExtensionType_default_instance_);
+}
+inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& SimpleExtensionDeclaration::extension_type() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.extension_type)
+  return _internal_extension_type();
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::unsafe_arena_release_extension_type() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.extensions.SimpleExtensionDeclaration.extension_type)
+  if (_internal_has_extension_type()) {
+    clear_has_mapping_type();
+    ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* temp = mapping_type_.extension_type_;
+    mapping_type_.extension_type_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_type(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type) {
+  clear_mapping_type();
+  if (extension_type) {
+    set_has_extension_type();
+    mapping_type_.extension_type_ = extension_type;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type)
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::_internal_mutable_extension_type() {
+  if (!_internal_has_extension_type()) {
+    clear_mapping_type();
+    set_has_extension_type();
+    mapping_type_.extension_type_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(GetArenaForAllocation());
+  }
+  return mapping_type_.extension_type_;
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::mutable_extension_type() {
+  ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* _msg = _internal_mutable_extension_type();
+  // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.extension_type)
+  return _msg;
+}
+
+// .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2;
+inline bool SimpleExtensionDeclaration::_internal_has_extension_type_variation() const {
+  return mapping_type_case() == kExtensionTypeVariation;
+}
+inline bool SimpleExtensionDeclaration::has_extension_type_variation() const {
+  return _internal_has_extension_type_variation();
+}
+inline void SimpleExtensionDeclaration::set_has_extension_type_variation() {
+  _oneof_case_[0] = kExtensionTypeVariation;
+}
+inline void SimpleExtensionDeclaration::clear_extension_type_variation() {
+  if (_internal_has_extension_type_variation()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete mapping_type_.extension_type_variation_;
+    }
+    clear_has_mapping_type();
+  }
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::release_extension_type_variation() {
+  // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation)
+  if (_internal_has_extension_type_variation()) {
+    clear_has_mapping_type();
+      ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* temp = mapping_type_.extension_type_variation_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    mapping_type_.extension_type_variation_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& SimpleExtensionDeclaration::_internal_extension_type_variation() const {
+  return _internal_has_extension_type_variation()
+      ? *mapping_type_.extension_type_variation_
+      : reinterpret_cast< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation&>(::substrait::extensions::_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_);
+}
+inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& SimpleExtensionDeclaration::extension_type_variation() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation)
+  return _internal_extension_type_variation();
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::unsafe_arena_release_extension_type_variation() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation)
+  if (_internal_has_extension_type_variation()) {
+    clear_has_mapping_type();
+    ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* temp = mapping_type_.extension_type_variation_;
+    mapping_type_.extension_type_variation_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_type_variation(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation) {
+  clear_mapping_type();
+  if (extension_type_variation) {
+    set_has_extension_type_variation();
+    mapping_type_.extension_type_variation_ = extension_type_variation;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation)
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::_internal_mutable_extension_type_variation() {
+  if (!_internal_has_extension_type_variation()) {
+    clear_mapping_type();
+    set_has_extension_type_variation();
+    mapping_type_.extension_type_variation_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(GetArenaForAllocation());
+  }
+  return mapping_type_.extension_type_variation_;
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::mutable_extension_type_variation() {
+  ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* _msg = _internal_mutable_extension_type_variation();
+  // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation)
+  return _msg;
+}
+
+// .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3;
+inline bool SimpleExtensionDeclaration::_internal_has_extension_function() const {
+  return mapping_type_case() == kExtensionFunction;
+}
+inline bool SimpleExtensionDeclaration::has_extension_function() const {
+  return _internal_has_extension_function();
+}
+inline void SimpleExtensionDeclaration::set_has_extension_function() {
+  _oneof_case_[0] = kExtensionFunction;
+}
+inline void SimpleExtensionDeclaration::clear_extension_function() {
+  if (_internal_has_extension_function()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete mapping_type_.extension_function_;
+    }
+    clear_has_mapping_type();
+  }
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::release_extension_function() {
+  // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.extension_function)
+  if (_internal_has_extension_function()) {
+    clear_has_mapping_type();
+      ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* temp = mapping_type_.extension_function_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    mapping_type_.extension_function_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& SimpleExtensionDeclaration::_internal_extension_function() const {
+  return _internal_has_extension_function()
+      ? *mapping_type_.extension_function_
+      : reinterpret_cast< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction&>(::substrait::extensions::_SimpleExtensionDeclaration_ExtensionFunction_default_instance_);
+}
+inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& SimpleExtensionDeclaration::extension_function() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.extension_function)
+  return _internal_extension_function();
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::unsafe_arena_release_extension_function() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.extensions.SimpleExtensionDeclaration.extension_function)
+  if (_internal_has_extension_function()) {
+    clear_has_mapping_type();
+    ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* temp = mapping_type_.extension_function_;
+    mapping_type_.extension_function_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_function(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function) {
+  clear_mapping_type();
+  if (extension_function) {
+    set_has_extension_function();
+    mapping_type_.extension_function_ = extension_function;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_function)
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::_internal_mutable_extension_function() {
+  if (!_internal_has_extension_function()) {
+    clear_mapping_type();
+    set_has_extension_function();
+    mapping_type_.extension_function_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(GetArenaForAllocation());
+  }
+  return mapping_type_.extension_function_;
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::mutable_extension_function() {
+  ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* _msg = _internal_mutable_extension_function();
+  // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.extension_function)
+  return _msg;
+}
+
+inline bool SimpleExtensionDeclaration::has_mapping_type() const {
+  return mapping_type_case() != MAPPING_TYPE_NOT_SET;
+}
+inline void SimpleExtensionDeclaration::clear_has_mapping_type() {
+  _oneof_case_[0] = MAPPING_TYPE_NOT_SET;
+}
+inline SimpleExtensionDeclaration::MappingTypeCase SimpleExtensionDeclaration::mapping_type_case() const {
+  return SimpleExtensionDeclaration::MappingTypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// AdvancedExtension
+
+// .google.protobuf.Any optimization = 1;
+inline bool AdvancedExtension::_internal_has_optimization() const {
+  return this != internal_default_instance() && optimization_ != nullptr;
+}
+inline bool AdvancedExtension::has_optimization() const {
+  return _internal_has_optimization();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_optimization() const {
+  const ::PROTOBUF_NAMESPACE_ID::Any* p = optimization_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
+      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::optimization() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.AdvancedExtension.optimization)
+  return _internal_optimization();
+}
+inline void AdvancedExtension::unsafe_arena_set_allocated_optimization(
+    ::PROTOBUF_NAMESPACE_ID::Any* optimization) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization_);
+  }
+  optimization_ = optimization;
+  if (optimization) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.AdvancedExtension.optimization)
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_optimization() {
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = optimization_;
+  optimization_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_optimization() {
+  // @@protoc_insertion_point(field_release:substrait.extensions.AdvancedExtension.optimization)
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = optimization_;
+  optimization_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_optimization() {
+  
+  if (optimization_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
+    optimization_ = p;
+  }
+  return optimization_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_optimization() {
+  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_optimization();
+  // @@protoc_insertion_point(field_mutable:substrait.extensions.AdvancedExtension.optimization)
+  return _msg;
+}
+inline void AdvancedExtension::set_allocated_optimization(::PROTOBUF_NAMESPACE_ID::Any* optimization) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization_);
+  }
+  if (optimization) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization));
+    if (message_arena != submessage_arena) {
+      optimization = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, optimization, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  optimization_ = optimization;
+  // @@protoc_insertion_point(field_set_allocated:substrait.extensions.AdvancedExtension.optimization)
+}
+
+// .google.protobuf.Any enhancement = 2;
+inline bool AdvancedExtension::_internal_has_enhancement() const {
+  return this != internal_default_instance() && enhancement_ != nullptr;
+}
+inline bool AdvancedExtension::has_enhancement() const {
+  return _internal_has_enhancement();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_enhancement() const {
+  const ::PROTOBUF_NAMESPACE_ID::Any* p = enhancement_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
+      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::enhancement() const {
+  // @@protoc_insertion_point(field_get:substrait.extensions.AdvancedExtension.enhancement)
+  return _internal_enhancement();
+}
+inline void AdvancedExtension::unsafe_arena_set_allocated_enhancement(
+    ::PROTOBUF_NAMESPACE_ID::Any* enhancement) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement_);
+  }
+  enhancement_ = enhancement;
+  if (enhancement) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.AdvancedExtension.enhancement)
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_enhancement() {
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_;
+  enhancement_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_enhancement() {
+  // @@protoc_insertion_point(field_release:substrait.extensions.AdvancedExtension.enhancement)
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_;
+  enhancement_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_enhancement() {
+  
+  if (enhancement_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
+    enhancement_ = p;
+  }
+  return enhancement_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_enhancement() {
+  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_enhancement();
+  // @@protoc_insertion_point(field_mutable:substrait.extensions.AdvancedExtension.enhancement)
+  return _msg;
+}
+inline void AdvancedExtension::set_allocated_enhancement(::PROTOBUF_NAMESPACE_ID::Any* enhancement) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement_);
+  }
+  if (enhancement) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement));
+    if (message_arena != submessage_arena) {
+      enhancement = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, enhancement, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  enhancement_ = enhancement;
+  // @@protoc_insertion_point(field_set_allocated:substrait.extensions.AdvancedExtension.enhancement)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace extensions
+}  // namespace substrait
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fextensions_2fextensions_2eproto
diff --git a/cpp/src/generated/substrait/function.pb.cc b/cpp/src/generated/substrait/function.pb.cc
new file mode 100644
index 000000000000..eb85050ab714
--- /dev/null
+++ b/cpp/src/generated/substrait/function.pb.cc
@@ -0,0 +1,4303 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/function.proto
+
+#include "substrait/function.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace substrait {
+constexpr FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : min_args_(int64_t{0})
+  , max_args_(int64_t{0})
+  , consistency_(0)
+{}
+struct FunctionSignature_FinalArgVariadicDefaultTypeInternal {
+  constexpr FunctionSignature_FinalArgVariadicDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FunctionSignature_FinalArgVariadicDefaultTypeInternal() {}
+  union {
+    FunctionSignature_FinalArgVariadic _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_FinalArgVariadicDefaultTypeInternal _FunctionSignature_FinalArgVariadic_default_instance_;
+constexpr FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
+struct FunctionSignature_FinalArgNormalDefaultTypeInternal {
+  constexpr FunctionSignature_FinalArgNormalDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FunctionSignature_FinalArgNormalDefaultTypeInternal() {}
+  union {
+    FunctionSignature_FinalArgNormal _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_FinalArgNormalDefaultTypeInternal _FunctionSignature_FinalArgNormal_default_instance_;
+constexpr FunctionSignature_Scalar::FunctionSignature_Scalar(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : arguments_()
+  , name_()
+  , implementations_()
+  , description_(nullptr)
+  , output_type_(nullptr)
+  , deterministic_(false)
+  , session_dependent_(false)
+  , _oneof_case_{}{}
+struct FunctionSignature_ScalarDefaultTypeInternal {
+  constexpr FunctionSignature_ScalarDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FunctionSignature_ScalarDefaultTypeInternal() {}
+  union {
+    FunctionSignature_Scalar _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ScalarDefaultTypeInternal _FunctionSignature_Scalar_default_instance_;
+constexpr FunctionSignature_Aggregate::FunctionSignature_Aggregate(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : arguments_()
+  , implementations_()
+  , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , description_(nullptr)
+  , output_type_(nullptr)
+  , intermediate_type_(nullptr)
+  , deterministic_(false)
+  , session_dependent_(false)
+  , ordered_(false)
+  , max_set_(uint64_t{0u})
+  , _oneof_case_{}{}
+struct FunctionSignature_AggregateDefaultTypeInternal {
+  constexpr FunctionSignature_AggregateDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FunctionSignature_AggregateDefaultTypeInternal() {}
+  union {
+    FunctionSignature_Aggregate _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_AggregateDefaultTypeInternal _FunctionSignature_Aggregate_default_instance_;
+constexpr FunctionSignature_Window::FunctionSignature_Window(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : arguments_()
+  , name_()
+  , implementations_()
+  , description_(nullptr)
+  , intermediate_type_(nullptr)
+  , output_type_(nullptr)
+  , deterministic_(false)
+  , session_dependent_(false)
+  , ordered_(false)
+  , window_type_(0)
+
+  , max_set_(uint64_t{0u})
+  , _oneof_case_{}{}
+struct FunctionSignature_WindowDefaultTypeInternal {
+  constexpr FunctionSignature_WindowDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FunctionSignature_WindowDefaultTypeInternal() {}
+  union {
+    FunctionSignature_Window _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_WindowDefaultTypeInternal _FunctionSignature_Window_default_instance_;
+constexpr FunctionSignature_Description::FunctionSignature_Description(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : language_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , body_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct FunctionSignature_DescriptionDefaultTypeInternal {
+  constexpr FunctionSignature_DescriptionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FunctionSignature_DescriptionDefaultTypeInternal() {}
+  union {
+    FunctionSignature_Description _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_DescriptionDefaultTypeInternal _FunctionSignature_Description_default_instance_;
+constexpr FunctionSignature_Implementation::FunctionSignature_Implementation(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , type_(0)
+{}
+struct FunctionSignature_ImplementationDefaultTypeInternal {
+  constexpr FunctionSignature_ImplementationDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FunctionSignature_ImplementationDefaultTypeInternal() {}
+  union {
+    FunctionSignature_Implementation _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ImplementationDefaultTypeInternal _FunctionSignature_Implementation_default_instance_;
+constexpr FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_(nullptr)
+  , constant_(false){}
+struct FunctionSignature_Argument_ValueArgumentDefaultTypeInternal {
+  constexpr FunctionSignature_Argument_ValueArgumentDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FunctionSignature_Argument_ValueArgumentDefaultTypeInternal() {}
+  union {
+    FunctionSignature_Argument_ValueArgument _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_Argument_ValueArgumentDefaultTypeInternal _FunctionSignature_Argument_ValueArgument_default_instance_;
+constexpr FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_(nullptr){}
+struct FunctionSignature_Argument_TypeArgumentDefaultTypeInternal {
+  constexpr FunctionSignature_Argument_TypeArgumentDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FunctionSignature_Argument_TypeArgumentDefaultTypeInternal() {}
+  union {
+    FunctionSignature_Argument_TypeArgument _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_Argument_TypeArgumentDefaultTypeInternal _FunctionSignature_Argument_TypeArgument_default_instance_;
+constexpr FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : options_()
+  , optional_(false){}
+struct FunctionSignature_Argument_EnumArgumentDefaultTypeInternal {
+  constexpr FunctionSignature_Argument_EnumArgumentDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FunctionSignature_Argument_EnumArgumentDefaultTypeInternal() {}
+  union {
+    FunctionSignature_Argument_EnumArgument _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_Argument_EnumArgumentDefaultTypeInternal _FunctionSignature_Argument_EnumArgument_default_instance_;
+constexpr FunctionSignature_Argument::FunctionSignature_Argument(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , _oneof_case_{}{}
+struct FunctionSignature_ArgumentDefaultTypeInternal {
+  constexpr FunctionSignature_ArgumentDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FunctionSignature_ArgumentDefaultTypeInternal() {}
+  union {
+    FunctionSignature_Argument _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ArgumentDefaultTypeInternal _FunctionSignature_Argument_default_instance_;
+constexpr FunctionSignature::FunctionSignature(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
+struct FunctionSignatureDefaultTypeInternal {
+  constexpr FunctionSignatureDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FunctionSignatureDefaultTypeInternal() {}
+  union {
+    FunctionSignature _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignatureDefaultTypeInternal _FunctionSignature_default_instance_;
+}  // namespace substrait
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ffunction_2eproto[12];
+static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ffunction_2eproto[3];
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ffunction_2eproto = nullptr;
+
+const uint32_t TableStruct_substrait_2ffunction_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, min_args_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, max_args_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, consistency_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgNormal, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, arguments_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, name_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, description_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, deterministic_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, session_dependent_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, output_type_),
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, implementations_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, final_variable_behavior_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, arguments_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, name_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, description_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, deterministic_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, session_dependent_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, output_type_),
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, ordered_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, max_set_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, intermediate_type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, implementations_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, final_variable_behavior_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, arguments_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, name_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, description_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, deterministic_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, session_dependent_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, intermediate_type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, output_type_),
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, ordered_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, max_set_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, window_type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, implementations_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, final_variable_behavior_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, language_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, body_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, uri_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, constant_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_TypeArgument, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_TypeArgument, type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, options_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, optional_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, name_),
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, argument_kind_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, -1, sizeof(::substrait::FunctionSignature_FinalArgVariadic)},
+  { 9, -1, -1, sizeof(::substrait::FunctionSignature_FinalArgNormal)},
+  { 15, -1, -1, sizeof(::substrait::FunctionSignature_Scalar)},
+  { 31, -1, -1, sizeof(::substrait::FunctionSignature_Aggregate)},
+  { 50, -1, -1, sizeof(::substrait::FunctionSignature_Window)},
+  { 70, -1, -1, sizeof(::substrait::FunctionSignature_Description)},
+  { 78, -1, -1, sizeof(::substrait::FunctionSignature_Implementation)},
+  { 86, -1, -1, sizeof(::substrait::FunctionSignature_Argument_ValueArgument)},
+  { 94, -1, -1, sizeof(::substrait::FunctionSignature_Argument_TypeArgument)},
+  { 101, -1, -1, sizeof(::substrait::FunctionSignature_Argument_EnumArgument)},
+  { 109, -1, -1, sizeof(::substrait::FunctionSignature_Argument)},
+  { 120, -1, -1, sizeof(::substrait::FunctionSignature)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_FinalArgVariadic_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_FinalArgNormal_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Scalar_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Aggregate_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Window_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Description_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Implementation_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_Argument_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FunctionSignature_default_instance_),
+};
+
+const char descriptor_table_protodef_substrait_2ffunction_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\030substrait/function.proto\022\tsubstrait\032\024s"
+  "ubstrait/type.proto\032#substrait/parameter"
+  "ized_types.proto\032 substrait/type_express"
+  "ions.proto\"\301\025\n\021FunctionSignature\032\235\002\n\020Fin"
+  "alArgVariadic\022\020\n\010min_args\030\001 \001(\003\022\020\n\010max_a"
+  "rgs\030\002 \001(\003\022W\n\013consistency\030\003 \001(\0162B.substra"
+  "it.FunctionSignature.FinalArgVariadic.Pa"
+  "rameterConsistency\"\213\001\n\024ParameterConsiste"
+  "ncy\022%\n!PARAMETER_CONSISTENCY_UNSPECIFIED"
+  "\020\000\022$\n PARAMETER_CONSISTENCY_CONSISTENT\020\001"
+  "\022&\n\"PARAMETER_CONSISTENCY_INCONSISTENT\020\002"
+  "\032\020\n\016FinalArgNormal\032\332\003\n\006Scalar\0228\n\targumen"
+  "ts\030\002 \003(\0132%.substrait.FunctionSignature.A"
+  "rgument\022\014\n\004name\030\003 \003(\t\022=\n\013description\030\004 \001"
+  "(\0132(.substrait.FunctionSignature.Descrip"
+  "tion\022\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_d"
+  "ependent\030\010 \001(\010\0224\n\013output_type\030\t \001(\0132\037.su"
+  "bstrait.DerivationExpression\022A\n\010variadic"
+  "\030\n \001(\0132-.substrait.FunctionSignature.Fin"
+  "alArgVariadicH\000\022=\n\006normal\030\013 \001(\0132+.substr"
+  "ait.FunctionSignature.FinalArgNormalH\000\022D"
+  "\n\017implementations\030\014 \003(\0132+.substrait.Func"
+  "tionSignature.ImplementationB\031\n\027final_va"
+  "riable_behavior\032\253\004\n\tAggregate\0228\n\targumen"
+  "ts\030\002 \003(\0132%.substrait.FunctionSignature.A"
+  "rgument\022\014\n\004name\030\003 \001(\t\022=\n\013description\030\004 \001"
+  "(\0132(.substrait.FunctionSignature.Descrip"
+  "tion\022\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_d"
+  "ependent\030\010 \001(\010\0224\n\013output_type\030\t \001(\0132\037.su"
+  "bstrait.DerivationExpression\022A\n\010variadic"
+  "\030\n \001(\0132-.substrait.FunctionSignature.Fin"
+  "alArgVariadicH\000\022=\n\006normal\030\013 \001(\0132+.substr"
+  "ait.FunctionSignature.FinalArgNormalH\000\022\017"
+  "\n\007ordered\030\016 \001(\010\022\017\n\007max_set\030\014 \001(\004\022*\n\021inte"
+  "rmediate_type\030\r \001(\0132\017.substrait.Type\022D\n\017"
+  "implementations\030\017 \003(\0132+.substrait.Functi"
+  "onSignature.ImplementationB\031\n\027final_vari"
+  "able_behavior\032\336\005\n\006Window\0228\n\targuments\030\002 "
+  "\003(\0132%.substrait.FunctionSignature.Argume"
+  "nt\022\014\n\004name\030\003 \003(\t\022=\n\013description\030\004 \001(\0132(."
+  "substrait.FunctionSignature.Description\022"
+  "\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_depend"
+  "ent\030\010 \001(\010\022:\n\021intermediate_type\030\t \001(\0132\037.s"
+  "ubstrait.DerivationExpression\0224\n\013output_"
+  "type\030\n \001(\0132\037.substrait.DerivationExpress"
+  "ion\022A\n\010variadic\030\020 \001(\0132-.substrait.Functi"
+  "onSignature.FinalArgVariadicH\000\022=\n\006normal"
+  "\030\021 \001(\0132+.substrait.FunctionSignature.Fin"
+  "alArgNormalH\000\022\017\n\007ordered\030\013 \001(\010\022\017\n\007max_se"
+  "t\030\014 \001(\004\022C\n\013window_type\030\016 \001(\0162..substrait"
+  ".FunctionSignature.Window.WindowType\022D\n\017"
+  "implementations\030\017 \003(\0132+.substrait.Functi"
+  "onSignature.Implementation\"_\n\nWindowType"
+  "\022\033\n\027WINDOW_TYPE_UNSPECIFIED\020\000\022\031\n\025WINDOW_"
+  "TYPE_STREAMING\020\001\022\031\n\025WINDOW_TYPE_PARTITIO"
+  "N\020\002B\031\n\027final_variable_behavior\032-\n\013Descri"
+  "ption\022\020\n\010language\030\001 \001(\t\022\014\n\004body\030\002 \001(\t\032\246\001"
+  "\n\016Implementation\022>\n\004type\030\001 \001(\01620.substra"
+  "it.FunctionSignature.Implementation.Type"
+  "\022\013\n\003uri\030\002 \001(\t\"G\n\004Type\022\024\n\020TYPE_UNSPECIFIE"
+  "D\020\000\022\025\n\021TYPE_WEB_ASSEMBLY\020\001\022\022\n\016TYPE_TRINO"
+  "_JAR\020\002\032\265\003\n\010Argument\022\014\n\004name\030\001 \001(\t\022D\n\005val"
+  "ue\030\002 \001(\01323.substrait.FunctionSignature.A"
+  "rgument.ValueArgumentH\000\022B\n\004type\030\003 \001(\01322."
+  "substrait.FunctionSignature.Argument.Typ"
+  "eArgumentH\000\022B\n\004enum\030\004 \001(\01322.substrait.Fu"
+  "nctionSignature.Argument.EnumArgumentH\000\032"
+  "M\n\rValueArgument\022*\n\004type\030\001 \001(\0132\034.substra"
+  "it.ParameterizedType\022\020\n\010constant\030\002 \001(\010\032:"
+  "\n\014TypeArgument\022*\n\004type\030\001 \001(\0132\034.substrait"
+  ".ParameterizedType\0321\n\014EnumArgument\022\017\n\007op"
+  "tions\030\001 \003(\t\022\020\n\010optional\030\002 \001(\010B\017\n\rargumen"
+  "t_kindB+\n\022io.substrait.protoP\001\252\002\022Substra"
+  "it.Protobufb\006proto3"
+  ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2ffunction_2eproto_deps[3] = {
+  &::descriptor_table_substrait_2fparameterized_5ftypes_2eproto,
+  &::descriptor_table_substrait_2ftype_2eproto,
+  &::descriptor_table_substrait_2ftype_5fexpressions_2eproto,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2ffunction_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ffunction_2eproto = {
+  false, false, 2939, descriptor_table_protodef_substrait_2ffunction_2eproto, "substrait/function.proto", 
+  &descriptor_table_substrait_2ffunction_2eproto_once, descriptor_table_substrait_2ffunction_2eproto_deps, 3, 12,
+  schemas, file_default_instances, TableStruct_substrait_2ffunction_2eproto::offsets,
+  file_level_metadata_substrait_2ffunction_2eproto, file_level_enum_descriptors_substrait_2ffunction_2eproto, file_level_service_descriptors_substrait_2ffunction_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2ffunction_2eproto_getter() {
+  return &descriptor_table_substrait_2ffunction_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2ffunction_2eproto(&descriptor_table_substrait_2ffunction_2eproto);
+namespace substrait {
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto);
+  return file_level_enum_descriptors_substrait_2ffunction_2eproto[0];
+}
+bool FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_UNSPECIFIED;
+constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_CONSISTENT;
+constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_INCONSISTENT;
+constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::ParameterConsistency_MIN;
+constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::ParameterConsistency_MAX;
+constexpr int FunctionSignature_FinalArgVariadic::ParameterConsistency_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Window_WindowType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto);
+  return file_level_enum_descriptors_substrait_2ffunction_2eproto[1];
+}
+bool FunctionSignature_Window_WindowType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_UNSPECIFIED;
+constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_STREAMING;
+constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_PARTITION;
+constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WindowType_MIN;
+constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WindowType_MAX;
+constexpr int FunctionSignature_Window::WindowType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Implementation_Type_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto);
+  return file_level_enum_descriptors_substrait_2ffunction_2eproto[2];
+}
+bool FunctionSignature_Implementation_Type_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_UNSPECIFIED;
+constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_WEB_ASSEMBLY;
+constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_TRINO_JAR;
+constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::Type_MIN;
+constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::Type_MAX;
+constexpr int FunctionSignature_Implementation::Type_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+
+// ===================================================================
+
+class FunctionSignature_FinalArgVariadic::_Internal {
+ public:
+};
+
+FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.FinalArgVariadic)
+}
+FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(const FunctionSignature_FinalArgVariadic& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&min_args_, &from.min_args_,
+    static_cast<size_t>(reinterpret_cast<char*>(&consistency_) -
+    reinterpret_cast<char*>(&min_args_)) + sizeof(consistency_));
+  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.FinalArgVariadic)
+}
+
+inline void FunctionSignature_FinalArgVariadic::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&min_args_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&consistency_) -
+    reinterpret_cast<char*>(&min_args_)) + sizeof(consistency_));
+}
+
+FunctionSignature_FinalArgVariadic::~FunctionSignature_FinalArgVariadic() {
+  // @@protoc_insertion_point(destructor:substrait.FunctionSignature.FinalArgVariadic)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void FunctionSignature_FinalArgVariadic::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void FunctionSignature_FinalArgVariadic::ArenaDtor(void* object) {
+  FunctionSignature_FinalArgVariadic* _this = reinterpret_cast< FunctionSignature_FinalArgVariadic* >(object);
+  (void)_this;
+}
+void FunctionSignature_FinalArgVariadic::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FunctionSignature_FinalArgVariadic::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FunctionSignature_FinalArgVariadic::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.FinalArgVariadic)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&min_args_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&consistency_) -
+      reinterpret_cast<char*>(&min_args_)) + sizeof(consistency_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FunctionSignature_FinalArgVariadic::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int64 min_args = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          min_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int64 max_args = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          max_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_consistency(static_cast<::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FunctionSignature_FinalArgVariadic::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.FinalArgVariadic)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int64 min_args = 1;
+  if (this->_internal_min_args() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_min_args(), target);
+  }
+
+  // int64 max_args = 2;
+  if (this->_internal_max_args() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_max_args(), target);
+  }
+
+  // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3;
+  if (this->_internal_consistency() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_consistency(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.FinalArgVariadic)
+  return target;
+}
+
+size_t FunctionSignature_FinalArgVariadic::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.FinalArgVariadic)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int64 min_args = 1;
+  if (this->_internal_min_args() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_min_args());
+  }
+
+  // int64 max_args = 2;
+  if (this->_internal_max_args() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_max_args());
+  }
+
+  // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3;
+  if (this->_internal_consistency() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_consistency());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_FinalArgVariadic::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    FunctionSignature_FinalArgVariadic::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_FinalArgVariadic::GetClassData() const { return &_class_data_; }
+
+void FunctionSignature_FinalArgVariadic::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<FunctionSignature_FinalArgVariadic *>(to)->MergeFrom(
+      static_cast<const FunctionSignature_FinalArgVariadic &>(from));
+}
+
+
+void FunctionSignature_FinalArgVariadic::MergeFrom(const FunctionSignature_FinalArgVariadic& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.FinalArgVariadic)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_min_args() != 0) {
+    _internal_set_min_args(from._internal_min_args());
+  }
+  if (from._internal_max_args() != 0) {
+    _internal_set_max_args(from._internal_max_args());
+  }
+  if (from._internal_consistency() != 0) {
+    _internal_set_consistency(from._internal_consistency());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FunctionSignature_FinalArgVariadic::CopyFrom(const FunctionSignature_FinalArgVariadic& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.FinalArgVariadic)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FunctionSignature_FinalArgVariadic::IsInitialized() const {
+  return true;
+}
+
+void FunctionSignature_FinalArgVariadic::InternalSwap(FunctionSignature_FinalArgVariadic* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(FunctionSignature_FinalArgVariadic, consistency_)
+      + sizeof(FunctionSignature_FinalArgVariadic::consistency_)
+      - PROTOBUF_FIELD_OFFSET(FunctionSignature_FinalArgVariadic, min_args_)>(
+          reinterpret_cast<char*>(&min_args_),
+          reinterpret_cast<char*>(&other->min_args_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_FinalArgVariadic::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
+      file_level_metadata_substrait_2ffunction_2eproto[0]);
+}
+
+// ===================================================================
+
+class FunctionSignature_FinalArgNormal::_Internal {
+ public:
+};
+
+FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
+  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.FinalArgNormal)
+}
+FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(const FunctionSignature_FinalArgNormal& from)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.FinalArgNormal)
+}
+
+
+
+
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_FinalArgNormal::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_FinalArgNormal::GetClassData() const { return &_class_data_; }
+
+
+
+
+
+
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_FinalArgNormal::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
+      file_level_metadata_substrait_2ffunction_2eproto[1]);
+}
+
+// ===================================================================
+
+class FunctionSignature_Scalar::_Internal {
+ public:
+  static const ::substrait::FunctionSignature_Description& description(const FunctionSignature_Scalar* msg);
+  static const ::substrait::DerivationExpression& output_type(const FunctionSignature_Scalar* msg);
+  static const ::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Scalar* msg);
+  static const ::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Scalar* msg);
+};
+
+const ::substrait::FunctionSignature_Description&
+FunctionSignature_Scalar::_Internal::description(const FunctionSignature_Scalar* msg) {
+  return *msg->description_;
+}
+const ::substrait::DerivationExpression&
+FunctionSignature_Scalar::_Internal::output_type(const FunctionSignature_Scalar* msg) {
+  return *msg->output_type_;
+}
+const ::substrait::FunctionSignature_FinalArgVariadic&
+FunctionSignature_Scalar::_Internal::variadic(const FunctionSignature_Scalar* msg) {
+  return *msg->final_variable_behavior_.variadic_;
+}
+const ::substrait::FunctionSignature_FinalArgNormal&
+FunctionSignature_Scalar::_Internal::normal(const FunctionSignature_Scalar* msg) {
+  return *msg->final_variable_behavior_.normal_;
+}
+void FunctionSignature_Scalar::clear_output_type() {
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+}
+void FunctionSignature_Scalar::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_final_variable_behavior();
+  if (variadic) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgVariadic>::GetOwningArena(variadic);
+    if (message_arena != submessage_arena) {
+      variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, variadic, submessage_arena);
+    }
+    set_has_variadic();
+    final_variable_behavior_.variadic_ = variadic;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.variadic)
+}
+void FunctionSignature_Scalar::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_final_variable_behavior();
+  if (normal) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgNormal>::GetOwningArena(normal);
+    if (message_arena != submessage_arena) {
+      normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, normal, submessage_arena);
+    }
+    set_has_normal();
+    final_variable_behavior_.normal_ = normal;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.normal)
+}
+FunctionSignature_Scalar::FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  arguments_(arena),
+  name_(arena),
+  implementations_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Scalar)
+}
+FunctionSignature_Scalar::FunctionSignature_Scalar(const FunctionSignature_Scalar& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      arguments_(from.arguments_),
+      name_(from.name_),
+      implementations_(from.implementations_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_description()) {
+    description_ = new ::substrait::FunctionSignature_Description(*from.description_);
+  } else {
+    description_ = nullptr;
+  }
+  if (from._internal_has_output_type()) {
+    output_type_ = new ::substrait::DerivationExpression(*from.output_type_);
+  } else {
+    output_type_ = nullptr;
+  }
+  ::memcpy(&deterministic_, &from.deterministic_,
+    static_cast<size_t>(reinterpret_cast<char*>(&session_dependent_) -
+    reinterpret_cast<char*>(&deterministic_)) + sizeof(session_dependent_));
+  clear_has_final_variable_behavior();
+  switch (from.final_variable_behavior_case()) {
+    case kVariadic: {
+      _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic());
+      break;
+    }
+    case kNormal: {
+      _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal());
+      break;
+    }
+    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Scalar)
+}
+
+inline void FunctionSignature_Scalar::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&description_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&session_dependent_) -
+    reinterpret_cast<char*>(&description_)) + sizeof(session_dependent_));
+clear_has_final_variable_behavior();
+}
+
+FunctionSignature_Scalar::~FunctionSignature_Scalar() {
+  // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Scalar)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void FunctionSignature_Scalar::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete description_;
+  if (this != internal_default_instance()) delete output_type_;
+  if (has_final_variable_behavior()) {
+    clear_final_variable_behavior();
+  }
+}
+
+void FunctionSignature_Scalar::ArenaDtor(void* object) {
+  FunctionSignature_Scalar* _this = reinterpret_cast< FunctionSignature_Scalar* >(object);
+  (void)_this;
+}
+void FunctionSignature_Scalar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FunctionSignature_Scalar::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FunctionSignature_Scalar::clear_final_variable_behavior() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Scalar)
+  switch (final_variable_behavior_case()) {
+    case kVariadic: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete final_variable_behavior_.variadic_;
+      }
+      break;
+    }
+    case kNormal: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete final_variable_behavior_.normal_;
+      }
+      break;
+    }
+    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET;
+}
+
+
+void FunctionSignature_Scalar::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Scalar)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  arguments_.Clear();
+  name_.Clear();
+  implementations_.Clear();
+  if (GetArenaForAllocation() == nullptr && description_ != nullptr) {
+    delete description_;
+  }
+  description_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+  ::memset(&deterministic_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&session_dependent_) -
+      reinterpret_cast<char*>(&deterministic_)) + sizeof(session_dependent_));
+  clear_final_variable_behavior();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FunctionSignature_Scalar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.FunctionSignature.Argument arguments = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_arguments(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string name = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_name();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Scalar.name"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.Description description = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_description(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool deterministic = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool session_dependent = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression output_type = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.FinalArgVariadic variadic = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.FinalArgNormal normal = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.FunctionSignature.Implementation implementations = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_implementations(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FunctionSignature_Scalar::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Scalar)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.FunctionSignature.Argument arguments = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_arguments_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_arguments(i), target, stream);
+  }
+
+  // repeated string name = 3;
+  for (int i = 0, n = this->_internal_name_size(); i < n; i++) {
+    const auto& s = this->_internal_name(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.FunctionSignature.Scalar.name");
+    target = stream->WriteString(3, s, target);
+  }
+
+  // .substrait.FunctionSignature.Description description = 4;
+  if (this->_internal_has_description()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::description(this), target, stream);
+  }
+
+  // bool deterministic = 7;
+  if (this->_internal_deterministic() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target);
+  }
+
+  // bool session_dependent = 8;
+  if (this->_internal_session_dependent() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target);
+  }
+
+  // .substrait.DerivationExpression output_type = 9;
+  if (this->_internal_has_output_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        9, _Internal::output_type(this), target, stream);
+  }
+
+  // .substrait.FunctionSignature.FinalArgVariadic variadic = 10;
+  if (_internal_has_variadic()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::variadic(this), target, stream);
+  }
+
+  // .substrait.FunctionSignature.FinalArgNormal normal = 11;
+  if (_internal_has_normal()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        11, _Internal::normal(this), target, stream);
+  }
+
+  // repeated .substrait.FunctionSignature.Implementation implementations = 12;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_implementations_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(12, this->_internal_implementations(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Scalar)
+  return target;
+}
+
+size_t FunctionSignature_Scalar::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Scalar)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.FunctionSignature.Argument arguments = 2;
+  total_size += 1UL * this->_internal_arguments_size();
+  for (const auto& msg : this->arguments_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated string name = 3;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(name_.size());
+  for (int i = 0, n = name_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      name_.Get(i));
+  }
+
+  // repeated .substrait.FunctionSignature.Implementation implementations = 12;
+  total_size += 1UL * this->_internal_implementations_size();
+  for (const auto& msg : this->implementations_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.FunctionSignature.Description description = 4;
+  if (this->_internal_has_description()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *description_);
+  }
+
+  // .substrait.DerivationExpression output_type = 9;
+  if (this->_internal_has_output_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *output_type_);
+  }
+
+  // bool deterministic = 7;
+  if (this->_internal_deterministic() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool session_dependent = 8;
+  if (this->_internal_session_dependent() != 0) {
+    total_size += 1 + 1;
+  }
+
+  switch (final_variable_behavior_case()) {
+    // .substrait.FunctionSignature.FinalArgVariadic variadic = 10;
+    case kVariadic: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *final_variable_behavior_.variadic_);
+      break;
+    }
+    // .substrait.FunctionSignature.FinalArgNormal normal = 11;
+    case kNormal: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *final_variable_behavior_.normal_);
+      break;
+    }
+    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Scalar::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    FunctionSignature_Scalar::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Scalar::GetClassData() const { return &_class_data_; }
+
+void FunctionSignature_Scalar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<FunctionSignature_Scalar *>(to)->MergeFrom(
+      static_cast<const FunctionSignature_Scalar &>(from));
+}
+
+
+void FunctionSignature_Scalar::MergeFrom(const FunctionSignature_Scalar& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Scalar)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  arguments_.MergeFrom(from.arguments_);
+  name_.MergeFrom(from.name_);
+  implementations_.MergeFrom(from.implementations_);
+  if (from._internal_has_description()) {
+    _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description());
+  }
+  if (from._internal_has_output_type()) {
+    _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type());
+  }
+  if (from._internal_deterministic() != 0) {
+    _internal_set_deterministic(from._internal_deterministic());
+  }
+  if (from._internal_session_dependent() != 0) {
+    _internal_set_session_dependent(from._internal_session_dependent());
+  }
+  switch (from.final_variable_behavior_case()) {
+    case kVariadic: {
+      _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic());
+      break;
+    }
+    case kNormal: {
+      _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal());
+      break;
+    }
+    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FunctionSignature_Scalar::CopyFrom(const FunctionSignature_Scalar& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Scalar)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FunctionSignature_Scalar::IsInitialized() const {
+  return true;
+}
+
+void FunctionSignature_Scalar::InternalSwap(FunctionSignature_Scalar* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  arguments_.InternalSwap(&other->arguments_);
+  name_.InternalSwap(&other->name_);
+  implementations_.InternalSwap(&other->implementations_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(FunctionSignature_Scalar, session_dependent_)
+      + sizeof(FunctionSignature_Scalar::session_dependent_)
+      - PROTOBUF_FIELD_OFFSET(FunctionSignature_Scalar, description_)>(
+          reinterpret_cast<char*>(&description_),
+          reinterpret_cast<char*>(&other->description_));
+  swap(final_variable_behavior_, other->final_variable_behavior_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Scalar::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
+      file_level_metadata_substrait_2ffunction_2eproto[2]);
+}
+
+// ===================================================================
+
+class FunctionSignature_Aggregate::_Internal {
+ public:
+  static const ::substrait::FunctionSignature_Description& description(const FunctionSignature_Aggregate* msg);
+  static const ::substrait::DerivationExpression& output_type(const FunctionSignature_Aggregate* msg);
+  static const ::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Aggregate* msg);
+  static const ::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Aggregate* msg);
+  static const ::substrait::Type& intermediate_type(const FunctionSignature_Aggregate* msg);
+};
+
+const ::substrait::FunctionSignature_Description&
+FunctionSignature_Aggregate::_Internal::description(const FunctionSignature_Aggregate* msg) {
+  return *msg->description_;
+}
+const ::substrait::DerivationExpression&
+FunctionSignature_Aggregate::_Internal::output_type(const FunctionSignature_Aggregate* msg) {
+  return *msg->output_type_;
+}
+const ::substrait::FunctionSignature_FinalArgVariadic&
+FunctionSignature_Aggregate::_Internal::variadic(const FunctionSignature_Aggregate* msg) {
+  return *msg->final_variable_behavior_.variadic_;
+}
+const ::substrait::FunctionSignature_FinalArgNormal&
+FunctionSignature_Aggregate::_Internal::normal(const FunctionSignature_Aggregate* msg) {
+  return *msg->final_variable_behavior_.normal_;
+}
+const ::substrait::Type&
+FunctionSignature_Aggregate::_Internal::intermediate_type(const FunctionSignature_Aggregate* msg) {
+  return *msg->intermediate_type_;
+}
+void FunctionSignature_Aggregate::clear_output_type() {
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+}
+void FunctionSignature_Aggregate::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_final_variable_behavior();
+  if (variadic) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgVariadic>::GetOwningArena(variadic);
+    if (message_arena != submessage_arena) {
+      variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, variadic, submessage_arena);
+    }
+    set_has_variadic();
+    final_variable_behavior_.variadic_ = variadic;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.variadic)
+}
+void FunctionSignature_Aggregate::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_final_variable_behavior();
+  if (normal) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgNormal>::GetOwningArena(normal);
+    if (message_arena != submessage_arena) {
+      normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, normal, submessage_arena);
+    }
+    set_has_normal();
+    final_variable_behavior_.normal_ = normal;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.normal)
+}
+void FunctionSignature_Aggregate::clear_intermediate_type() {
+  if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) {
+    delete intermediate_type_;
+  }
+  intermediate_type_ = nullptr;
+}
+FunctionSignature_Aggregate::FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  arguments_(arena),
+  implementations_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Aggregate)
+}
+FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature_Aggregate& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      arguments_(from.arguments_),
+      implementations_(from.implementations_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_name().empty()) {
+    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
+      GetArenaForAllocation());
+  }
+  if (from._internal_has_description()) {
+    description_ = new ::substrait::FunctionSignature_Description(*from.description_);
+  } else {
+    description_ = nullptr;
+  }
+  if (from._internal_has_output_type()) {
+    output_type_ = new ::substrait::DerivationExpression(*from.output_type_);
+  } else {
+    output_type_ = nullptr;
+  }
+  if (from._internal_has_intermediate_type()) {
+    intermediate_type_ = new ::substrait::Type(*from.intermediate_type_);
+  } else {
+    intermediate_type_ = nullptr;
+  }
+  ::memcpy(&deterministic_, &from.deterministic_,
+    static_cast<size_t>(reinterpret_cast<char*>(&max_set_) -
+    reinterpret_cast<char*>(&deterministic_)) + sizeof(max_set_));
+  clear_has_final_variable_behavior();
+  switch (from.final_variable_behavior_case()) {
+    case kVariadic: {
+      _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic());
+      break;
+    }
+    case kNormal: {
+      _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal());
+      break;
+    }
+    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Aggregate)
+}
+
+inline void FunctionSignature_Aggregate::SharedCtor() {
+name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&description_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&max_set_) -
+    reinterpret_cast<char*>(&description_)) + sizeof(max_set_));
+clear_has_final_variable_behavior();
+}
+
+FunctionSignature_Aggregate::~FunctionSignature_Aggregate() {
+  // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Aggregate)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void FunctionSignature_Aggregate::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (this != internal_default_instance()) delete description_;
+  if (this != internal_default_instance()) delete output_type_;
+  if (this != internal_default_instance()) delete intermediate_type_;
+  if (has_final_variable_behavior()) {
+    clear_final_variable_behavior();
+  }
+}
+
+void FunctionSignature_Aggregate::ArenaDtor(void* object) {
+  FunctionSignature_Aggregate* _this = reinterpret_cast< FunctionSignature_Aggregate* >(object);
+  (void)_this;
+}
+void FunctionSignature_Aggregate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FunctionSignature_Aggregate::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FunctionSignature_Aggregate::clear_final_variable_behavior() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Aggregate)
+  switch (final_variable_behavior_case()) {
+    case kVariadic: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete final_variable_behavior_.variadic_;
+      }
+      break;
+    }
+    case kNormal: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete final_variable_behavior_.normal_;
+      }
+      break;
+    }
+    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET;
+}
+
+
+void FunctionSignature_Aggregate::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Aggregate)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  arguments_.Clear();
+  implementations_.Clear();
+  name_.ClearToEmpty();
+  if (GetArenaForAllocation() == nullptr && description_ != nullptr) {
+    delete description_;
+  }
+  description_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) {
+    delete intermediate_type_;
+  }
+  intermediate_type_ = nullptr;
+  ::memset(&deterministic_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&max_set_) -
+      reinterpret_cast<char*>(&deterministic_)) + sizeof(max_set_));
+  clear_final_variable_behavior();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.FunctionSignature.Argument arguments = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_arguments(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // string name = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_name();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Aggregate.name"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.Description description = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_description(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool deterministic = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool session_dependent = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression output_type = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.FinalArgVariadic variadic = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.FinalArgNormal normal = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint64 max_set = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          max_set_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type intermediate_type = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          ptr = ctx->ParseMessage(_internal_mutable_intermediate_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool ordered = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
+          ordered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.FunctionSignature.Implementation implementations = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_implementations(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FunctionSignature_Aggregate::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Aggregate)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.FunctionSignature.Argument arguments = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_arguments_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_arguments(i), target, stream);
+  }
+
+  // string name = 3;
+  if (!this->_internal_name().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.FunctionSignature.Aggregate.name");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_name(), target);
+  }
+
+  // .substrait.FunctionSignature.Description description = 4;
+  if (this->_internal_has_description()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::description(this), target, stream);
+  }
+
+  // bool deterministic = 7;
+  if (this->_internal_deterministic() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target);
+  }
+
+  // bool session_dependent = 8;
+  if (this->_internal_session_dependent() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target);
+  }
+
+  // .substrait.DerivationExpression output_type = 9;
+  if (this->_internal_has_output_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        9, _Internal::output_type(this), target, stream);
+  }
+
+  // .substrait.FunctionSignature.FinalArgVariadic variadic = 10;
+  if (_internal_has_variadic()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::variadic(this), target, stream);
+  }
+
+  // .substrait.FunctionSignature.FinalArgNormal normal = 11;
+  if (_internal_has_normal()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        11, _Internal::normal(this), target, stream);
+  }
+
+  // uint64 max_set = 12;
+  if (this->_internal_max_set() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_max_set(), target);
+  }
+
+  // .substrait.Type intermediate_type = 13;
+  if (this->_internal_has_intermediate_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        13, _Internal::intermediate_type(this), target, stream);
+  }
+
+  // bool ordered = 14;
+  if (this->_internal_ordered() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(14, this->_internal_ordered(), target);
+  }
+
+  // repeated .substrait.FunctionSignature.Implementation implementations = 15;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_implementations_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(15, this->_internal_implementations(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Aggregate)
+  return target;
+}
+
+size_t FunctionSignature_Aggregate::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Aggregate)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.FunctionSignature.Argument arguments = 2;
+  total_size += 1UL * this->_internal_arguments_size();
+  for (const auto& msg : this->arguments_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .substrait.FunctionSignature.Implementation implementations = 15;
+  total_size += 1UL * this->_internal_implementations_size();
+  for (const auto& msg : this->implementations_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // string name = 3;
+  if (!this->_internal_name().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  // .substrait.FunctionSignature.Description description = 4;
+  if (this->_internal_has_description()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *description_);
+  }
+
+  // .substrait.DerivationExpression output_type = 9;
+  if (this->_internal_has_output_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *output_type_);
+  }
+
+  // .substrait.Type intermediate_type = 13;
+  if (this->_internal_has_intermediate_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *intermediate_type_);
+  }
+
+  // bool deterministic = 7;
+  if (this->_internal_deterministic() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool session_dependent = 8;
+  if (this->_internal_session_dependent() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool ordered = 14;
+  if (this->_internal_ordered() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // uint64 max_set = 12;
+  if (this->_internal_max_set() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_max_set());
+  }
+
+  switch (final_variable_behavior_case()) {
+    // .substrait.FunctionSignature.FinalArgVariadic variadic = 10;
+    case kVariadic: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *final_variable_behavior_.variadic_);
+      break;
+    }
+    // .substrait.FunctionSignature.FinalArgNormal normal = 11;
+    case kNormal: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *final_variable_behavior_.normal_);
+      break;
+    }
+    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Aggregate::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    FunctionSignature_Aggregate::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Aggregate::GetClassData() const { return &_class_data_; }
+
+void FunctionSignature_Aggregate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<FunctionSignature_Aggregate *>(to)->MergeFrom(
+      static_cast<const FunctionSignature_Aggregate &>(from));
+}
+
+
+void FunctionSignature_Aggregate::MergeFrom(const FunctionSignature_Aggregate& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Aggregate)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  arguments_.MergeFrom(from.arguments_);
+  implementations_.MergeFrom(from.implementations_);
+  if (!from._internal_name().empty()) {
+    _internal_set_name(from._internal_name());
+  }
+  if (from._internal_has_description()) {
+    _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description());
+  }
+  if (from._internal_has_output_type()) {
+    _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type());
+  }
+  if (from._internal_has_intermediate_type()) {
+    _internal_mutable_intermediate_type()->::substrait::Type::MergeFrom(from._internal_intermediate_type());
+  }
+  if (from._internal_deterministic() != 0) {
+    _internal_set_deterministic(from._internal_deterministic());
+  }
+  if (from._internal_session_dependent() != 0) {
+    _internal_set_session_dependent(from._internal_session_dependent());
+  }
+  if (from._internal_ordered() != 0) {
+    _internal_set_ordered(from._internal_ordered());
+  }
+  if (from._internal_max_set() != 0) {
+    _internal_set_max_set(from._internal_max_set());
+  }
+  switch (from.final_variable_behavior_case()) {
+    case kVariadic: {
+      _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic());
+      break;
+    }
+    case kNormal: {
+      _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal());
+      break;
+    }
+    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FunctionSignature_Aggregate::CopyFrom(const FunctionSignature_Aggregate& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Aggregate)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FunctionSignature_Aggregate::IsInitialized() const {
+  return true;
+}
+
+void FunctionSignature_Aggregate::InternalSwap(FunctionSignature_Aggregate* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  arguments_.InternalSwap(&other->arguments_);
+  implementations_.InternalSwap(&other->implementations_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &name_, lhs_arena,
+      &other->name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, max_set_)
+      + sizeof(FunctionSignature_Aggregate::max_set_)
+      - PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, description_)>(
+          reinterpret_cast<char*>(&description_),
+          reinterpret_cast<char*>(&other->description_));
+  swap(final_variable_behavior_, other->final_variable_behavior_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Aggregate::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
+      file_level_metadata_substrait_2ffunction_2eproto[3]);
+}
+
+// ===================================================================
+
+class FunctionSignature_Window::_Internal {
+ public:
+  static const ::substrait::FunctionSignature_Description& description(const FunctionSignature_Window* msg);
+  static const ::substrait::DerivationExpression& intermediate_type(const FunctionSignature_Window* msg);
+  static const ::substrait::DerivationExpression& output_type(const FunctionSignature_Window* msg);
+  static const ::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Window* msg);
+  static const ::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Window* msg);
+};
+
+const ::substrait::FunctionSignature_Description&
+FunctionSignature_Window::_Internal::description(const FunctionSignature_Window* msg) {
+  return *msg->description_;
+}
+const ::substrait::DerivationExpression&
+FunctionSignature_Window::_Internal::intermediate_type(const FunctionSignature_Window* msg) {
+  return *msg->intermediate_type_;
+}
+const ::substrait::DerivationExpression&
+FunctionSignature_Window::_Internal::output_type(const FunctionSignature_Window* msg) {
+  return *msg->output_type_;
+}
+const ::substrait::FunctionSignature_FinalArgVariadic&
+FunctionSignature_Window::_Internal::variadic(const FunctionSignature_Window* msg) {
+  return *msg->final_variable_behavior_.variadic_;
+}
+const ::substrait::FunctionSignature_FinalArgNormal&
+FunctionSignature_Window::_Internal::normal(const FunctionSignature_Window* msg) {
+  return *msg->final_variable_behavior_.normal_;
+}
+void FunctionSignature_Window::clear_intermediate_type() {
+  if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) {
+    delete intermediate_type_;
+  }
+  intermediate_type_ = nullptr;
+}
+void FunctionSignature_Window::clear_output_type() {
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+}
+void FunctionSignature_Window::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_final_variable_behavior();
+  if (variadic) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgVariadic>::GetOwningArena(variadic);
+    if (message_arena != submessage_arena) {
+      variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, variadic, submessage_arena);
+    }
+    set_has_variadic();
+    final_variable_behavior_.variadic_ = variadic;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.variadic)
+}
+void FunctionSignature_Window::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_final_variable_behavior();
+  if (normal) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgNormal>::GetOwningArena(normal);
+    if (message_arena != submessage_arena) {
+      normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, normal, submessage_arena);
+    }
+    set_has_normal();
+    final_variable_behavior_.normal_ = normal;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.normal)
+}
+FunctionSignature_Window::FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  arguments_(arena),
+  name_(arena),
+  implementations_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Window)
+}
+FunctionSignature_Window::FunctionSignature_Window(const FunctionSignature_Window& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      arguments_(from.arguments_),
+      name_(from.name_),
+      implementations_(from.implementations_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_description()) {
+    description_ = new ::substrait::FunctionSignature_Description(*from.description_);
+  } else {
+    description_ = nullptr;
+  }
+  if (from._internal_has_intermediate_type()) {
+    intermediate_type_ = new ::substrait::DerivationExpression(*from.intermediate_type_);
+  } else {
+    intermediate_type_ = nullptr;
+  }
+  if (from._internal_has_output_type()) {
+    output_type_ = new ::substrait::DerivationExpression(*from.output_type_);
+  } else {
+    output_type_ = nullptr;
+  }
+  ::memcpy(&deterministic_, &from.deterministic_,
+    static_cast<size_t>(reinterpret_cast<char*>(&max_set_) -
+    reinterpret_cast<char*>(&deterministic_)) + sizeof(max_set_));
+  clear_has_final_variable_behavior();
+  switch (from.final_variable_behavior_case()) {
+    case kVariadic: {
+      _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic());
+      break;
+    }
+    case kNormal: {
+      _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal());
+      break;
+    }
+    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Window)
+}
+
+inline void FunctionSignature_Window::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&description_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&max_set_) -
+    reinterpret_cast<char*>(&description_)) + sizeof(max_set_));
+clear_has_final_variable_behavior();
+}
+
+FunctionSignature_Window::~FunctionSignature_Window() {
+  // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Window)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void FunctionSignature_Window::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete description_;
+  if (this != internal_default_instance()) delete intermediate_type_;
+  if (this != internal_default_instance()) delete output_type_;
+  if (has_final_variable_behavior()) {
+    clear_final_variable_behavior();
+  }
+}
+
+void FunctionSignature_Window::ArenaDtor(void* object) {
+  FunctionSignature_Window* _this = reinterpret_cast< FunctionSignature_Window* >(object);
+  (void)_this;
+}
+void FunctionSignature_Window::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FunctionSignature_Window::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FunctionSignature_Window::clear_final_variable_behavior() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Window)
+  switch (final_variable_behavior_case()) {
+    case kVariadic: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete final_variable_behavior_.variadic_;
+      }
+      break;
+    }
+    case kNormal: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete final_variable_behavior_.normal_;
+      }
+      break;
+    }
+    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET;
+}
+
+
+void FunctionSignature_Window::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Window)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  arguments_.Clear();
+  name_.Clear();
+  implementations_.Clear();
+  if (GetArenaForAllocation() == nullptr && description_ != nullptr) {
+    delete description_;
+  }
+  description_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) {
+    delete intermediate_type_;
+  }
+  intermediate_type_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) {
+    delete output_type_;
+  }
+  output_type_ = nullptr;
+  ::memset(&deterministic_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&max_set_) -
+      reinterpret_cast<char*>(&deterministic_)) + sizeof(max_set_));
+  clear_final_variable_behavior();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.FunctionSignature.Argument arguments = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_arguments(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string name = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_name();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Window.name"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.Description description = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_description(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool deterministic = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool session_dependent = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression intermediate_type = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_intermediate_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression output_type = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool ordered = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
+          ordered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint64 max_set = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
+          max_set_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.Window.WindowType window_type = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_window_type(static_cast<::substrait::FunctionSignature_Window_WindowType>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.FunctionSignature.Implementation implementations = 15;
+      case 15:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 122)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_implementations(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.FinalArgVariadic variadic = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.FinalArgNormal normal = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FunctionSignature_Window::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Window)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.FunctionSignature.Argument arguments = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_arguments_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_arguments(i), target, stream);
+  }
+
+  // repeated string name = 3;
+  for (int i = 0, n = this->_internal_name_size(); i < n; i++) {
+    const auto& s = this->_internal_name(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.FunctionSignature.Window.name");
+    target = stream->WriteString(3, s, target);
+  }
+
+  // .substrait.FunctionSignature.Description description = 4;
+  if (this->_internal_has_description()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::description(this), target, stream);
+  }
+
+  // bool deterministic = 7;
+  if (this->_internal_deterministic() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target);
+  }
+
+  // bool session_dependent = 8;
+  if (this->_internal_session_dependent() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target);
+  }
+
+  // .substrait.DerivationExpression intermediate_type = 9;
+  if (this->_internal_has_intermediate_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        9, _Internal::intermediate_type(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression output_type = 10;
+  if (this->_internal_has_output_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::output_type(this), target, stream);
+  }
+
+  // bool ordered = 11;
+  if (this->_internal_ordered() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(11, this->_internal_ordered(), target);
+  }
+
+  // uint64 max_set = 12;
+  if (this->_internal_max_set() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_max_set(), target);
+  }
+
+  // .substrait.FunctionSignature.Window.WindowType window_type = 14;
+  if (this->_internal_window_type() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      14, this->_internal_window_type(), target);
+  }
+
+  // repeated .substrait.FunctionSignature.Implementation implementations = 15;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_implementations_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(15, this->_internal_implementations(i), target, stream);
+  }
+
+  // .substrait.FunctionSignature.FinalArgVariadic variadic = 16;
+  if (_internal_has_variadic()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        16, _Internal::variadic(this), target, stream);
+  }
+
+  // .substrait.FunctionSignature.FinalArgNormal normal = 17;
+  if (_internal_has_normal()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        17, _Internal::normal(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Window)
+  return target;
+}
+
+size_t FunctionSignature_Window::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Window)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.FunctionSignature.Argument arguments = 2;
+  total_size += 1UL * this->_internal_arguments_size();
+  for (const auto& msg : this->arguments_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated string name = 3;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(name_.size());
+  for (int i = 0, n = name_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      name_.Get(i));
+  }
+
+  // repeated .substrait.FunctionSignature.Implementation implementations = 15;
+  total_size += 1UL * this->_internal_implementations_size();
+  for (const auto& msg : this->implementations_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.FunctionSignature.Description description = 4;
+  if (this->_internal_has_description()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *description_);
+  }
+
+  // .substrait.DerivationExpression intermediate_type = 9;
+  if (this->_internal_has_intermediate_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *intermediate_type_);
+  }
+
+  // .substrait.DerivationExpression output_type = 10;
+  if (this->_internal_has_output_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *output_type_);
+  }
+
+  // bool deterministic = 7;
+  if (this->_internal_deterministic() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool session_dependent = 8;
+  if (this->_internal_session_dependent() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // bool ordered = 11;
+  if (this->_internal_ordered() != 0) {
+    total_size += 1 + 1;
+  }
+
+  // .substrait.FunctionSignature.Window.WindowType window_type = 14;
+  if (this->_internal_window_type() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_window_type());
+  }
+
+  // uint64 max_set = 12;
+  if (this->_internal_max_set() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_max_set());
+  }
+
+  switch (final_variable_behavior_case()) {
+    // .substrait.FunctionSignature.FinalArgVariadic variadic = 16;
+    case kVariadic: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *final_variable_behavior_.variadic_);
+      break;
+    }
+    // .substrait.FunctionSignature.FinalArgNormal normal = 17;
+    case kNormal: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *final_variable_behavior_.normal_);
+      break;
+    }
+    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Window::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    FunctionSignature_Window::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Window::GetClassData() const { return &_class_data_; }
+
+void FunctionSignature_Window::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<FunctionSignature_Window *>(to)->MergeFrom(
+      static_cast<const FunctionSignature_Window &>(from));
+}
+
+
+void FunctionSignature_Window::MergeFrom(const FunctionSignature_Window& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Window)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  arguments_.MergeFrom(from.arguments_);
+  name_.MergeFrom(from.name_);
+  implementations_.MergeFrom(from.implementations_);
+  if (from._internal_has_description()) {
+    _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description());
+  }
+  if (from._internal_has_intermediate_type()) {
+    _internal_mutable_intermediate_type()->::substrait::DerivationExpression::MergeFrom(from._internal_intermediate_type());
+  }
+  if (from._internal_has_output_type()) {
+    _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type());
+  }
+  if (from._internal_deterministic() != 0) {
+    _internal_set_deterministic(from._internal_deterministic());
+  }
+  if (from._internal_session_dependent() != 0) {
+    _internal_set_session_dependent(from._internal_session_dependent());
+  }
+  if (from._internal_ordered() != 0) {
+    _internal_set_ordered(from._internal_ordered());
+  }
+  if (from._internal_window_type() != 0) {
+    _internal_set_window_type(from._internal_window_type());
+  }
+  if (from._internal_max_set() != 0) {
+    _internal_set_max_set(from._internal_max_set());
+  }
+  switch (from.final_variable_behavior_case()) {
+    case kVariadic: {
+      _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic());
+      break;
+    }
+    case kNormal: {
+      _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal());
+      break;
+    }
+    case FINAL_VARIABLE_BEHAVIOR_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FunctionSignature_Window::CopyFrom(const FunctionSignature_Window& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Window)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FunctionSignature_Window::IsInitialized() const {
+  return true;
+}
+
+void FunctionSignature_Window::InternalSwap(FunctionSignature_Window* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  arguments_.InternalSwap(&other->arguments_);
+  name_.InternalSwap(&other->name_);
+  implementations_.InternalSwap(&other->implementations_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(FunctionSignature_Window, max_set_)
+      + sizeof(FunctionSignature_Window::max_set_)
+      - PROTOBUF_FIELD_OFFSET(FunctionSignature_Window, description_)>(
+          reinterpret_cast<char*>(&description_),
+          reinterpret_cast<char*>(&other->description_));
+  swap(final_variable_behavior_, other->final_variable_behavior_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Window::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
+      file_level_metadata_substrait_2ffunction_2eproto[4]);
+}
+
+// ===================================================================
+
+class FunctionSignature_Description::_Internal {
+ public:
+};
+
+FunctionSignature_Description::FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Description)
+}
+FunctionSignature_Description::FunctionSignature_Description(const FunctionSignature_Description& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  language_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    language_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_language().empty()) {
+    language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_language(), 
+      GetArenaForAllocation());
+  }
+  body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_body().empty()) {
+    body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_body(), 
+      GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Description)
+}
+
+inline void FunctionSignature_Description::SharedCtor() {
+language_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  language_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+FunctionSignature_Description::~FunctionSignature_Description() {
+  // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Description)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void FunctionSignature_Description::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  language_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  body_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void FunctionSignature_Description::ArenaDtor(void* object) {
+  FunctionSignature_Description* _this = reinterpret_cast< FunctionSignature_Description* >(object);
+  (void)_this;
+}
+void FunctionSignature_Description::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FunctionSignature_Description::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FunctionSignature_Description::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Description)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  language_.ClearToEmpty();
+  body_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FunctionSignature_Description::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string language = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_language();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Description.language"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string body = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_body();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Description.body"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FunctionSignature_Description::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Description)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string language = 1;
+  if (!this->_internal_language().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_language().data(), static_cast<int>(this->_internal_language().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.FunctionSignature.Description.language");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_language(), target);
+  }
+
+  // string body = 2;
+  if (!this->_internal_body().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_body().data(), static_cast<int>(this->_internal_body().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.FunctionSignature.Description.body");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_body(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Description)
+  return target;
+}
+
+size_t FunctionSignature_Description::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Description)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string language = 1;
+  if (!this->_internal_language().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_language());
+  }
+
+  // string body = 2;
+  if (!this->_internal_body().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_body());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Description::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    FunctionSignature_Description::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Description::GetClassData() const { return &_class_data_; }
+
+void FunctionSignature_Description::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<FunctionSignature_Description *>(to)->MergeFrom(
+      static_cast<const FunctionSignature_Description &>(from));
+}
+
+
+void FunctionSignature_Description::MergeFrom(const FunctionSignature_Description& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Description)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_language().empty()) {
+    _internal_set_language(from._internal_language());
+  }
+  if (!from._internal_body().empty()) {
+    _internal_set_body(from._internal_body());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FunctionSignature_Description::CopyFrom(const FunctionSignature_Description& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Description)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FunctionSignature_Description::IsInitialized() const {
+  return true;
+}
+
+void FunctionSignature_Description::InternalSwap(FunctionSignature_Description* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &language_, lhs_arena,
+      &other->language_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &body_, lhs_arena,
+      &other->body_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Description::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
+      file_level_metadata_substrait_2ffunction_2eproto[5]);
+}
+
+// ===================================================================
+
+class FunctionSignature_Implementation::_Internal {
+ public:
+};
+
+FunctionSignature_Implementation::FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Implementation)
+}
+FunctionSignature_Implementation::FunctionSignature_Implementation(const FunctionSignature_Implementation& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_uri().empty()) {
+    uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), 
+      GetArenaForAllocation());
+  }
+  type_ = from.type_;
+  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Implementation)
+}
+
+inline void FunctionSignature_Implementation::SharedCtor() {
+uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+type_ = 0;
+}
+
+FunctionSignature_Implementation::~FunctionSignature_Implementation() {
+  // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Implementation)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void FunctionSignature_Implementation::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void FunctionSignature_Implementation::ArenaDtor(void* object) {
+  FunctionSignature_Implementation* _this = reinterpret_cast< FunctionSignature_Implementation* >(object);
+  (void)_this;
+}
+void FunctionSignature_Implementation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FunctionSignature_Implementation::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FunctionSignature_Implementation::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Implementation)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  uri_.ClearToEmpty();
+  type_ = 0;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FunctionSignature_Implementation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.FunctionSignature.Implementation.Type type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_type(static_cast<::substrait::FunctionSignature_Implementation_Type>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      // string uri = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_uri();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Implementation.uri"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FunctionSignature_Implementation::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Implementation)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.FunctionSignature.Implementation.Type type = 1;
+  if (this->_internal_type() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_type(), target);
+  }
+
+  // string uri = 2;
+  if (!this->_internal_uri().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_uri().data(), static_cast<int>(this->_internal_uri().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.FunctionSignature.Implementation.uri");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_uri(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Implementation)
+  return target;
+}
+
+size_t FunctionSignature_Implementation::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Implementation)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string uri = 2;
+  if (!this->_internal_uri().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_uri());
+  }
+
+  // .substrait.FunctionSignature.Implementation.Type type = 1;
+  if (this->_internal_type() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Implementation::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    FunctionSignature_Implementation::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Implementation::GetClassData() const { return &_class_data_; }
+
+void FunctionSignature_Implementation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<FunctionSignature_Implementation *>(to)->MergeFrom(
+      static_cast<const FunctionSignature_Implementation &>(from));
+}
+
+
+void FunctionSignature_Implementation::MergeFrom(const FunctionSignature_Implementation& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Implementation)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_uri().empty()) {
+    _internal_set_uri(from._internal_uri());
+  }
+  if (from._internal_type() != 0) {
+    _internal_set_type(from._internal_type());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FunctionSignature_Implementation::CopyFrom(const FunctionSignature_Implementation& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Implementation)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FunctionSignature_Implementation::IsInitialized() const {
+  return true;
+}
+
+void FunctionSignature_Implementation::InternalSwap(FunctionSignature_Implementation* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &uri_, lhs_arena,
+      &other->uri_, rhs_arena
+  );
+  swap(type_, other->type_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Implementation::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
+      file_level_metadata_substrait_2ffunction_2eproto[6]);
+}
+
+// ===================================================================
+
+class FunctionSignature_Argument_ValueArgument::_Internal {
+ public:
+  static const ::substrait::ParameterizedType& type(const FunctionSignature_Argument_ValueArgument* msg);
+};
+
+const ::substrait::ParameterizedType&
+FunctionSignature_Argument_ValueArgument::_Internal::type(const FunctionSignature_Argument_ValueArgument* msg) {
+  return *msg->type_;
+}
+void FunctionSignature_Argument_ValueArgument::clear_type() {
+  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
+    delete type_;
+  }
+  type_ = nullptr;
+}
+FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument.ValueArgument)
+}
+FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(const FunctionSignature_Argument_ValueArgument& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_type()) {
+    type_ = new ::substrait::ParameterizedType(*from.type_);
+  } else {
+    type_ = nullptr;
+  }
+  constant_ = from.constant_;
+  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.ValueArgument)
+}
+
+inline void FunctionSignature_Argument_ValueArgument::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&constant_) -
+    reinterpret_cast<char*>(&type_)) + sizeof(constant_));
+}
+
+FunctionSignature_Argument_ValueArgument::~FunctionSignature_Argument_ValueArgument() {
+  // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument.ValueArgument)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void FunctionSignature_Argument_ValueArgument::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete type_;
+}
+
+void FunctionSignature_Argument_ValueArgument::ArenaDtor(void* object) {
+  FunctionSignature_Argument_ValueArgument* _this = reinterpret_cast< FunctionSignature_Argument_ValueArgument* >(object);
+  (void)_this;
+}
+void FunctionSignature_Argument_ValueArgument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FunctionSignature_Argument_ValueArgument::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FunctionSignature_Argument_ValueArgument::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.ValueArgument)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
+    delete type_;
+  }
+  type_ = nullptr;
+  constant_ = false;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FunctionSignature_Argument_ValueArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.ParameterizedType type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // bool constant = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          constant_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FunctionSignature_Argument_ValueArgument::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.ValueArgument)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType type = 1;
+  if (this->_internal_has_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::type(this), target, stream);
+  }
+
+  // bool constant = 2;
+  if (this->_internal_constant() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_constant(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Argument.ValueArgument)
+  return target;
+}
+
+size_t FunctionSignature_Argument_ValueArgument::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.ValueArgument)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType type = 1;
+  if (this->_internal_has_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *type_);
+  }
+
+  // bool constant = 2;
+  if (this->_internal_constant() != 0) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Argument_ValueArgument::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    FunctionSignature_Argument_ValueArgument::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Argument_ValueArgument::GetClassData() const { return &_class_data_; }
+
+void FunctionSignature_Argument_ValueArgument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<FunctionSignature_Argument_ValueArgument *>(to)->MergeFrom(
+      static_cast<const FunctionSignature_Argument_ValueArgument &>(from));
+}
+
+
+void FunctionSignature_Argument_ValueArgument::MergeFrom(const FunctionSignature_Argument_ValueArgument& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument.ValueArgument)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_type()) {
+    _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type());
+  }
+  if (from._internal_constant() != 0) {
+    _internal_set_constant(from._internal_constant());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FunctionSignature_Argument_ValueArgument::CopyFrom(const FunctionSignature_Argument_ValueArgument& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Argument.ValueArgument)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FunctionSignature_Argument_ValueArgument::IsInitialized() const {
+  return true;
+}
+
+void FunctionSignature_Argument_ValueArgument::InternalSwap(FunctionSignature_Argument_ValueArgument* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(FunctionSignature_Argument_ValueArgument, constant_)
+      + sizeof(FunctionSignature_Argument_ValueArgument::constant_)
+      - PROTOBUF_FIELD_OFFSET(FunctionSignature_Argument_ValueArgument, type_)>(
+          reinterpret_cast<char*>(&type_),
+          reinterpret_cast<char*>(&other->type_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_ValueArgument::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
+      file_level_metadata_substrait_2ffunction_2eproto[7]);
+}
+
+// ===================================================================
+
+class FunctionSignature_Argument_TypeArgument::_Internal {
+ public:
+  static const ::substrait::ParameterizedType& type(const FunctionSignature_Argument_TypeArgument* msg);
+};
+
+const ::substrait::ParameterizedType&
+FunctionSignature_Argument_TypeArgument::_Internal::type(const FunctionSignature_Argument_TypeArgument* msg) {
+  return *msg->type_;
+}
+void FunctionSignature_Argument_TypeArgument::clear_type() {
+  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
+    delete type_;
+  }
+  type_ = nullptr;
+}
+FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument.TypeArgument)
+}
+FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(const FunctionSignature_Argument_TypeArgument& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_type()) {
+    type_ = new ::substrait::ParameterizedType(*from.type_);
+  } else {
+    type_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.TypeArgument)
+}
+
+inline void FunctionSignature_Argument_TypeArgument::SharedCtor() {
+type_ = nullptr;
+}
+
+FunctionSignature_Argument_TypeArgument::~FunctionSignature_Argument_TypeArgument() {
+  // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument.TypeArgument)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void FunctionSignature_Argument_TypeArgument::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete type_;
+}
+
+void FunctionSignature_Argument_TypeArgument::ArenaDtor(void* object) {
+  FunctionSignature_Argument_TypeArgument* _this = reinterpret_cast< FunctionSignature_Argument_TypeArgument* >(object);
+  (void)_this;
+}
+void FunctionSignature_Argument_TypeArgument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FunctionSignature_Argument_TypeArgument::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FunctionSignature_Argument_TypeArgument::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.TypeArgument)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
+    delete type_;
+  }
+  type_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FunctionSignature_Argument_TypeArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.ParameterizedType type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FunctionSignature_Argument_TypeArgument::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.TypeArgument)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType type = 1;
+  if (this->_internal_has_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::type(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Argument.TypeArgument)
+  return target;
+}
+
+size_t FunctionSignature_Argument_TypeArgument::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.TypeArgument)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType type = 1;
+  if (this->_internal_has_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *type_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Argument_TypeArgument::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    FunctionSignature_Argument_TypeArgument::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Argument_TypeArgument::GetClassData() const { return &_class_data_; }
+
+void FunctionSignature_Argument_TypeArgument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<FunctionSignature_Argument_TypeArgument *>(to)->MergeFrom(
+      static_cast<const FunctionSignature_Argument_TypeArgument &>(from));
+}
+
+
+void FunctionSignature_Argument_TypeArgument::MergeFrom(const FunctionSignature_Argument_TypeArgument& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument.TypeArgument)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_type()) {
+    _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FunctionSignature_Argument_TypeArgument::CopyFrom(const FunctionSignature_Argument_TypeArgument& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Argument.TypeArgument)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FunctionSignature_Argument_TypeArgument::IsInitialized() const {
+  return true;
+}
+
+void FunctionSignature_Argument_TypeArgument::InternalSwap(FunctionSignature_Argument_TypeArgument* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(type_, other->type_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_TypeArgument::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
+      file_level_metadata_substrait_2ffunction_2eproto[8]);
+}
+
+// ===================================================================
+
+class FunctionSignature_Argument_EnumArgument::_Internal {
+ public:
+};
+
+FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  options_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument.EnumArgument)
+}
+FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(const FunctionSignature_Argument_EnumArgument& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      options_(from.options_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  optional_ = from.optional_;
+  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.EnumArgument)
+}
+
+inline void FunctionSignature_Argument_EnumArgument::SharedCtor() {
+optional_ = false;
+}
+
+FunctionSignature_Argument_EnumArgument::~FunctionSignature_Argument_EnumArgument() {
+  // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument.EnumArgument)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void FunctionSignature_Argument_EnumArgument::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void FunctionSignature_Argument_EnumArgument::ArenaDtor(void* object) {
+  FunctionSignature_Argument_EnumArgument* _this = reinterpret_cast< FunctionSignature_Argument_EnumArgument* >(object);
+  (void)_this;
+}
+void FunctionSignature_Argument_EnumArgument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FunctionSignature_Argument_EnumArgument::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FunctionSignature_Argument_EnumArgument::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.EnumArgument)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  options_.Clear();
+  optional_ = false;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FunctionSignature_Argument_EnumArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated string options = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_options();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Argument.EnumArgument.options"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // bool optional = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          optional_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FunctionSignature_Argument_EnumArgument::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.EnumArgument)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string options = 1;
+  for (int i = 0, n = this->_internal_options_size(); i < n; i++) {
+    const auto& s = this->_internal_options(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.FunctionSignature.Argument.EnumArgument.options");
+    target = stream->WriteString(1, s, target);
+  }
+
+  // bool optional = 2;
+  if (this->_internal_optional() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_optional(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Argument.EnumArgument)
+  return target;
+}
+
+size_t FunctionSignature_Argument_EnumArgument::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.EnumArgument)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string options = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(options_.size());
+  for (int i = 0, n = options_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      options_.Get(i));
+  }
+
+  // bool optional = 2;
+  if (this->_internal_optional() != 0) {
+    total_size += 1 + 1;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Argument_EnumArgument::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    FunctionSignature_Argument_EnumArgument::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Argument_EnumArgument::GetClassData() const { return &_class_data_; }
+
+void FunctionSignature_Argument_EnumArgument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<FunctionSignature_Argument_EnumArgument *>(to)->MergeFrom(
+      static_cast<const FunctionSignature_Argument_EnumArgument &>(from));
+}
+
+
+void FunctionSignature_Argument_EnumArgument::MergeFrom(const FunctionSignature_Argument_EnumArgument& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument.EnumArgument)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  options_.MergeFrom(from.options_);
+  if (from._internal_optional() != 0) {
+    _internal_set_optional(from._internal_optional());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FunctionSignature_Argument_EnumArgument::CopyFrom(const FunctionSignature_Argument_EnumArgument& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Argument.EnumArgument)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FunctionSignature_Argument_EnumArgument::IsInitialized() const {
+  return true;
+}
+
+void FunctionSignature_Argument_EnumArgument::InternalSwap(FunctionSignature_Argument_EnumArgument* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  options_.InternalSwap(&other->options_);
+  swap(optional_, other->optional_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_EnumArgument::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
+      file_level_metadata_substrait_2ffunction_2eproto[9]);
+}
+
+// ===================================================================
+
+class FunctionSignature_Argument::_Internal {
+ public:
+  static const ::substrait::FunctionSignature_Argument_ValueArgument& value(const FunctionSignature_Argument* msg);
+  static const ::substrait::FunctionSignature_Argument_TypeArgument& type(const FunctionSignature_Argument* msg);
+  static const ::substrait::FunctionSignature_Argument_EnumArgument& enum_(const FunctionSignature_Argument* msg);
+};
+
+const ::substrait::FunctionSignature_Argument_ValueArgument&
+FunctionSignature_Argument::_Internal::value(const FunctionSignature_Argument* msg) {
+  return *msg->argument_kind_.value_;
+}
+const ::substrait::FunctionSignature_Argument_TypeArgument&
+FunctionSignature_Argument::_Internal::type(const FunctionSignature_Argument* msg) {
+  return *msg->argument_kind_.type_;
+}
+const ::substrait::FunctionSignature_Argument_EnumArgument&
+FunctionSignature_Argument::_Internal::enum_(const FunctionSignature_Argument* msg) {
+  return *msg->argument_kind_.enum__;
+}
+void FunctionSignature_Argument::set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_argument_kind();
+  if (value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Argument_ValueArgument>::GetOwningArena(value);
+    if (message_arena != submessage_arena) {
+      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, value, submessage_arena);
+    }
+    set_has_value();
+    argument_kind_.value_ = value;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.value)
+}
+void FunctionSignature_Argument::set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_argument_kind();
+  if (type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Argument_TypeArgument>::GetOwningArena(type);
+    if (message_arena != submessage_arena) {
+      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, type, submessage_arena);
+    }
+    set_has_type();
+    argument_kind_.type_ = type;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.type)
+}
+void FunctionSignature_Argument::set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_argument_kind();
+  if (enum_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Argument_EnumArgument>::GetOwningArena(enum_);
+    if (message_arena != submessage_arena) {
+      enum_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, enum_, submessage_arena);
+    }
+    set_has_enum_();
+    argument_kind_.enum__ = enum_;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.enum)
+}
+FunctionSignature_Argument::FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument)
+}
+FunctionSignature_Argument::FunctionSignature_Argument(const FunctionSignature_Argument& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_name().empty()) {
+    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
+      GetArenaForAllocation());
+  }
+  clear_has_argument_kind();
+  switch (from.argument_kind_case()) {
+    case kValue: {
+      _internal_mutable_value()->::substrait::FunctionSignature_Argument_ValueArgument::MergeFrom(from._internal_value());
+      break;
+    }
+    case kType: {
+      _internal_mutable_type()->::substrait::FunctionSignature_Argument_TypeArgument::MergeFrom(from._internal_type());
+      break;
+    }
+    case kEnum: {
+      _internal_mutable_enum_()->::substrait::FunctionSignature_Argument_EnumArgument::MergeFrom(from._internal_enum_());
+      break;
+    }
+    case ARGUMENT_KIND_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument)
+}
+
+inline void FunctionSignature_Argument::SharedCtor() {
+name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+clear_has_argument_kind();
+}
+
+FunctionSignature_Argument::~FunctionSignature_Argument() {
+  // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void FunctionSignature_Argument::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (has_argument_kind()) {
+    clear_argument_kind();
+  }
+}
+
+void FunctionSignature_Argument::ArenaDtor(void* object) {
+  FunctionSignature_Argument* _this = reinterpret_cast< FunctionSignature_Argument* >(object);
+  (void)_this;
+}
+void FunctionSignature_Argument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FunctionSignature_Argument::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FunctionSignature_Argument::clear_argument_kind() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Argument)
+  switch (argument_kind_case()) {
+    case kValue: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete argument_kind_.value_;
+      }
+      break;
+    }
+    case kType: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete argument_kind_.type_;
+      }
+      break;
+    }
+    case kEnum: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete argument_kind_.enum__;
+      }
+      break;
+    }
+    case ARGUMENT_KIND_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = ARGUMENT_KIND_NOT_SET;
+}
+
+
+void FunctionSignature_Argument::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  name_.ClearToEmpty();
+  clear_argument_kind();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FunctionSignature_Argument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Argument.name"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.Argument.ValueArgument value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.Argument.TypeArgument type = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FunctionSignature.Argument.EnumArgument enum = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FunctionSignature_Argument::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string name = 1;
+  if (!this->_internal_name().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.FunctionSignature.Argument.name");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // .substrait.FunctionSignature.Argument.ValueArgument value = 2;
+  if (_internal_has_value()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::value(this), target, stream);
+  }
+
+  // .substrait.FunctionSignature.Argument.TypeArgument type = 3;
+  if (_internal_has_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::type(this), target, stream);
+  }
+
+  // .substrait.FunctionSignature.Argument.EnumArgument enum = 4;
+  if (_internal_has_enum_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::enum_(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Argument)
+  return target;
+}
+
+size_t FunctionSignature_Argument::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string name = 1;
+  if (!this->_internal_name().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  switch (argument_kind_case()) {
+    // .substrait.FunctionSignature.Argument.ValueArgument value = 2;
+    case kValue: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *argument_kind_.value_);
+      break;
+    }
+    // .substrait.FunctionSignature.Argument.TypeArgument type = 3;
+    case kType: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *argument_kind_.type_);
+      break;
+    }
+    // .substrait.FunctionSignature.Argument.EnumArgument enum = 4;
+    case kEnum: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *argument_kind_.enum__);
+      break;
+    }
+    case ARGUMENT_KIND_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Argument::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    FunctionSignature_Argument::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Argument::GetClassData() const { return &_class_data_; }
+
+void FunctionSignature_Argument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<FunctionSignature_Argument *>(to)->MergeFrom(
+      static_cast<const FunctionSignature_Argument &>(from));
+}
+
+
+void FunctionSignature_Argument::MergeFrom(const FunctionSignature_Argument& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_name().empty()) {
+    _internal_set_name(from._internal_name());
+  }
+  switch (from.argument_kind_case()) {
+    case kValue: {
+      _internal_mutable_value()->::substrait::FunctionSignature_Argument_ValueArgument::MergeFrom(from._internal_value());
+      break;
+    }
+    case kType: {
+      _internal_mutable_type()->::substrait::FunctionSignature_Argument_TypeArgument::MergeFrom(from._internal_type());
+      break;
+    }
+    case kEnum: {
+      _internal_mutable_enum_()->::substrait::FunctionSignature_Argument_EnumArgument::MergeFrom(from._internal_enum_());
+      break;
+    }
+    case ARGUMENT_KIND_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FunctionSignature_Argument::CopyFrom(const FunctionSignature_Argument& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Argument)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FunctionSignature_Argument::IsInitialized() const {
+  return true;
+}
+
+void FunctionSignature_Argument::InternalSwap(FunctionSignature_Argument* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &name_, lhs_arena,
+      &other->name_, rhs_arena
+  );
+  swap(argument_kind_, other->argument_kind_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
+      file_level_metadata_substrait_2ffunction_2eproto[10]);
+}
+
+// ===================================================================
+
+class FunctionSignature::_Internal {
+ public:
+};
+
+FunctionSignature::FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
+  // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature)
+}
+FunctionSignature::FunctionSignature(const FunctionSignature& from)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature)
+}
+
+
+
+
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature::GetClassData() const { return &_class_data_; }
+
+
+
+
+
+
+
+::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once,
+      file_level_metadata_substrait_2ffunction_2eproto[11]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_FinalArgVariadic* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_FinalArgVariadic >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_FinalArgNormal* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_FinalArgNormal >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Scalar* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Scalar >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Scalar >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Aggregate* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Aggregate >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Aggregate >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Window* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Window >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Window >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Description* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Description >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Description >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Implementation* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Implementation >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Implementation >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument_ValueArgument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument_ValueArgument >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument_ValueArgument >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument_TypeArgument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument_TypeArgument >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument_TypeArgument >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument_EnumArgument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument_EnumArgument >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument_EnumArgument >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature* Arena::CreateMaybeMessage< ::substrait::FunctionSignature >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FunctionSignature >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/cpp/src/generated/substrait/function.pb.h b/cpp/src/generated/substrait/function.pb.h
new file mode 100644
index 000000000000..e566263d2f63
--- /dev/null
+++ b/cpp/src/generated/substrait/function.pb.h
@@ -0,0 +1,5553 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/function.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2ffunction_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_substrait_2ffunction_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3019000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3019003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_bases.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "substrait/type.pb.h"
+#include "substrait/parameterized_types.pb.h"
+#include "substrait/type_expressions.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_substrait_2ffunction_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_substrait_2ffunction_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[12]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ffunction_2eproto;
+namespace substrait {
+class FunctionSignature;
+struct FunctionSignatureDefaultTypeInternal;
+extern FunctionSignatureDefaultTypeInternal _FunctionSignature_default_instance_;
+class FunctionSignature_Aggregate;
+struct FunctionSignature_AggregateDefaultTypeInternal;
+extern FunctionSignature_AggregateDefaultTypeInternal _FunctionSignature_Aggregate_default_instance_;
+class FunctionSignature_Argument;
+struct FunctionSignature_ArgumentDefaultTypeInternal;
+extern FunctionSignature_ArgumentDefaultTypeInternal _FunctionSignature_Argument_default_instance_;
+class FunctionSignature_Argument_EnumArgument;
+struct FunctionSignature_Argument_EnumArgumentDefaultTypeInternal;
+extern FunctionSignature_Argument_EnumArgumentDefaultTypeInternal _FunctionSignature_Argument_EnumArgument_default_instance_;
+class FunctionSignature_Argument_TypeArgument;
+struct FunctionSignature_Argument_TypeArgumentDefaultTypeInternal;
+extern FunctionSignature_Argument_TypeArgumentDefaultTypeInternal _FunctionSignature_Argument_TypeArgument_default_instance_;
+class FunctionSignature_Argument_ValueArgument;
+struct FunctionSignature_Argument_ValueArgumentDefaultTypeInternal;
+extern FunctionSignature_Argument_ValueArgumentDefaultTypeInternal _FunctionSignature_Argument_ValueArgument_default_instance_;
+class FunctionSignature_Description;
+struct FunctionSignature_DescriptionDefaultTypeInternal;
+extern FunctionSignature_DescriptionDefaultTypeInternal _FunctionSignature_Description_default_instance_;
+class FunctionSignature_FinalArgNormal;
+struct FunctionSignature_FinalArgNormalDefaultTypeInternal;
+extern FunctionSignature_FinalArgNormalDefaultTypeInternal _FunctionSignature_FinalArgNormal_default_instance_;
+class FunctionSignature_FinalArgVariadic;
+struct FunctionSignature_FinalArgVariadicDefaultTypeInternal;
+extern FunctionSignature_FinalArgVariadicDefaultTypeInternal _FunctionSignature_FinalArgVariadic_default_instance_;
+class FunctionSignature_Implementation;
+struct FunctionSignature_ImplementationDefaultTypeInternal;
+extern FunctionSignature_ImplementationDefaultTypeInternal _FunctionSignature_Implementation_default_instance_;
+class FunctionSignature_Scalar;
+struct FunctionSignature_ScalarDefaultTypeInternal;
+extern FunctionSignature_ScalarDefaultTypeInternal _FunctionSignature_Scalar_default_instance_;
+class FunctionSignature_Window;
+struct FunctionSignature_WindowDefaultTypeInternal;
+extern FunctionSignature_WindowDefaultTypeInternal _FunctionSignature_Window_default_instance_;
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> ::substrait::FunctionSignature* Arena::CreateMaybeMessage<::substrait::FunctionSignature>(Arena*);
+template<> ::substrait::FunctionSignature_Aggregate* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Aggregate>(Arena*);
+template<> ::substrait::FunctionSignature_Argument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument>(Arena*);
+template<> ::substrait::FunctionSignature_Argument_EnumArgument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument_EnumArgument>(Arena*);
+template<> ::substrait::FunctionSignature_Argument_TypeArgument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument_TypeArgument>(Arena*);
+template<> ::substrait::FunctionSignature_Argument_ValueArgument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument_ValueArgument>(Arena*);
+template<> ::substrait::FunctionSignature_Description* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Description>(Arena*);
+template<> ::substrait::FunctionSignature_FinalArgNormal* Arena::CreateMaybeMessage<::substrait::FunctionSignature_FinalArgNormal>(Arena*);
+template<> ::substrait::FunctionSignature_FinalArgVariadic* Arena::CreateMaybeMessage<::substrait::FunctionSignature_FinalArgVariadic>(Arena*);
+template<> ::substrait::FunctionSignature_Implementation* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Implementation>(Arena*);
+template<> ::substrait::FunctionSignature_Scalar* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Scalar>(Arena*);
+template<> ::substrait::FunctionSignature_Window* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Window>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace substrait {
+
+enum FunctionSignature_FinalArgVariadic_ParameterConsistency : int {
+  FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED = 0,
+  FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_CONSISTENT = 1,
+  FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT = 2,
+  FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(int value);
+constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MIN = FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED;
+constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX = FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT;
+constexpr int FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_ARRAYSIZE = FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor();
+template<typename T>
+inline const std::string& FunctionSignature_FinalArgVariadic_ParameterConsistency_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, FunctionSignature_FinalArgVariadic_ParameterConsistency>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function FunctionSignature_FinalArgVariadic_ParameterConsistency_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(), enum_t_value);
+}
+inline bool FunctionSignature_FinalArgVariadic_ParameterConsistency_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSignature_FinalArgVariadic_ParameterConsistency* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FunctionSignature_FinalArgVariadic_ParameterConsistency>(
+    FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(), name, value);
+}
+enum FunctionSignature_Window_WindowType : int {
+  FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED = 0,
+  FunctionSignature_Window_WindowType_WINDOW_TYPE_STREAMING = 1,
+  FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION = 2,
+  FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool FunctionSignature_Window_WindowType_IsValid(int value);
+constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MIN = FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED;
+constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MAX = FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION;
+constexpr int FunctionSignature_Window_WindowType_WindowType_ARRAYSIZE = FunctionSignature_Window_WindowType_WindowType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Window_WindowType_descriptor();
+template<typename T>
+inline const std::string& FunctionSignature_Window_WindowType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, FunctionSignature_Window_WindowType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function FunctionSignature_Window_WindowType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    FunctionSignature_Window_WindowType_descriptor(), enum_t_value);
+}
+inline bool FunctionSignature_Window_WindowType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSignature_Window_WindowType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FunctionSignature_Window_WindowType>(
+    FunctionSignature_Window_WindowType_descriptor(), name, value);
+}
+enum FunctionSignature_Implementation_Type : int {
+  FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED = 0,
+  FunctionSignature_Implementation_Type_TYPE_WEB_ASSEMBLY = 1,
+  FunctionSignature_Implementation_Type_TYPE_TRINO_JAR = 2,
+  FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool FunctionSignature_Implementation_Type_IsValid(int value);
+constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MIN = FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED;
+constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MAX = FunctionSignature_Implementation_Type_TYPE_TRINO_JAR;
+constexpr int FunctionSignature_Implementation_Type_Type_ARRAYSIZE = FunctionSignature_Implementation_Type_Type_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Implementation_Type_descriptor();
+template<typename T>
+inline const std::string& FunctionSignature_Implementation_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, FunctionSignature_Implementation_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function FunctionSignature_Implementation_Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    FunctionSignature_Implementation_Type_descriptor(), enum_t_value);
+}
+inline bool FunctionSignature_Implementation_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSignature_Implementation_Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<FunctionSignature_Implementation_Type>(
+    FunctionSignature_Implementation_Type_descriptor(), name, value);
+}
+// ===================================================================
+
+class FunctionSignature_FinalArgVariadic final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.FinalArgVariadic) */ {
+ public:
+  inline FunctionSignature_FinalArgVariadic() : FunctionSignature_FinalArgVariadic(nullptr) {}
+  ~FunctionSignature_FinalArgVariadic() override;
+  explicit constexpr FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionSignature_FinalArgVariadic(const FunctionSignature_FinalArgVariadic& from);
+  FunctionSignature_FinalArgVariadic(FunctionSignature_FinalArgVariadic&& from) noexcept
+    : FunctionSignature_FinalArgVariadic() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionSignature_FinalArgVariadic& operator=(const FunctionSignature_FinalArgVariadic& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionSignature_FinalArgVariadic& operator=(FunctionSignature_FinalArgVariadic&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionSignature_FinalArgVariadic& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FunctionSignature_FinalArgVariadic* internal_default_instance() {
+    return reinterpret_cast<const FunctionSignature_FinalArgVariadic*>(
+               &_FunctionSignature_FinalArgVariadic_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(FunctionSignature_FinalArgVariadic& a, FunctionSignature_FinalArgVariadic& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionSignature_FinalArgVariadic* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionSignature_FinalArgVariadic* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionSignature_FinalArgVariadic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionSignature_FinalArgVariadic>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionSignature_FinalArgVariadic& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const FunctionSignature_FinalArgVariadic& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionSignature_FinalArgVariadic* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FunctionSignature.FinalArgVariadic";
+  }
+  protected:
+  explicit FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FunctionSignature_FinalArgVariadic_ParameterConsistency ParameterConsistency;
+  static constexpr ParameterConsistency PARAMETER_CONSISTENCY_UNSPECIFIED =
+    FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED;
+  static constexpr ParameterConsistency PARAMETER_CONSISTENCY_CONSISTENT =
+    FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_CONSISTENT;
+  static constexpr ParameterConsistency PARAMETER_CONSISTENCY_INCONSISTENT =
+    FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT;
+  static inline bool ParameterConsistency_IsValid(int value) {
+    return FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(value);
+  }
+  static constexpr ParameterConsistency ParameterConsistency_MIN =
+    FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MIN;
+  static constexpr ParameterConsistency ParameterConsistency_MAX =
+    FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX;
+  static constexpr int ParameterConsistency_ARRAYSIZE =
+    FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ParameterConsistency_descriptor() {
+    return FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ParameterConsistency_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ParameterConsistency>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ParameterConsistency_Name.");
+    return FunctionSignature_FinalArgVariadic_ParameterConsistency_Name(enum_t_value);
+  }
+  static inline bool ParameterConsistency_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ParameterConsistency* value) {
+    return FunctionSignature_FinalArgVariadic_ParameterConsistency_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMinArgsFieldNumber = 1,
+    kMaxArgsFieldNumber = 2,
+    kConsistencyFieldNumber = 3,
+  };
+  // int64 min_args = 1;
+  void clear_min_args();
+  int64_t min_args() const;
+  void set_min_args(int64_t value);
+  private:
+  int64_t _internal_min_args() const;
+  void _internal_set_min_args(int64_t value);
+  public:
+
+  // int64 max_args = 2;
+  void clear_max_args();
+  int64_t max_args() const;
+  void set_max_args(int64_t value);
+  private:
+  int64_t _internal_max_args() const;
+  void _internal_set_max_args(int64_t value);
+  public:
+
+  // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3;
+  void clear_consistency();
+  ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency consistency() const;
+  void set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value);
+  private:
+  ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency _internal_consistency() const;
+  void _internal_set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.FinalArgVariadic)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int64_t min_args_;
+  int64_t max_args_;
+  int consistency_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionSignature_FinalArgNormal final :
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.FinalArgNormal) */ {
+ public:
+  inline FunctionSignature_FinalArgNormal() : FunctionSignature_FinalArgNormal(nullptr) {}
+  explicit constexpr FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionSignature_FinalArgNormal(const FunctionSignature_FinalArgNormal& from);
+  FunctionSignature_FinalArgNormal(FunctionSignature_FinalArgNormal&& from) noexcept
+    : FunctionSignature_FinalArgNormal() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionSignature_FinalArgNormal& operator=(const FunctionSignature_FinalArgNormal& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionSignature_FinalArgNormal& operator=(FunctionSignature_FinalArgNormal&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionSignature_FinalArgNormal& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FunctionSignature_FinalArgNormal* internal_default_instance() {
+    return reinterpret_cast<const FunctionSignature_FinalArgNormal*>(
+               &_FunctionSignature_FinalArgNormal_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(FunctionSignature_FinalArgNormal& a, FunctionSignature_FinalArgNormal& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionSignature_FinalArgNormal* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionSignature_FinalArgNormal* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionSignature_FinalArgNormal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionSignature_FinalArgNormal>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
+  inline void CopyFrom(const FunctionSignature_FinalArgNormal& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
+  void MergeFrom(const FunctionSignature_FinalArgNormal& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
+  }
+  public:
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FunctionSignature.FinalArgNormal";
+  }
+  protected:
+  explicit FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.FinalArgNormal)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionSignature_Scalar final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Scalar) */ {
+ public:
+  inline FunctionSignature_Scalar() : FunctionSignature_Scalar(nullptr) {}
+  ~FunctionSignature_Scalar() override;
+  explicit constexpr FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionSignature_Scalar(const FunctionSignature_Scalar& from);
+  FunctionSignature_Scalar(FunctionSignature_Scalar&& from) noexcept
+    : FunctionSignature_Scalar() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionSignature_Scalar& operator=(const FunctionSignature_Scalar& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionSignature_Scalar& operator=(FunctionSignature_Scalar&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionSignature_Scalar& default_instance() {
+    return *internal_default_instance();
+  }
+  enum FinalVariableBehaviorCase {
+    kVariadic = 10,
+    kNormal = 11,
+    FINAL_VARIABLE_BEHAVIOR_NOT_SET = 0,
+  };
+
+  static inline const FunctionSignature_Scalar* internal_default_instance() {
+    return reinterpret_cast<const FunctionSignature_Scalar*>(
+               &_FunctionSignature_Scalar_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(FunctionSignature_Scalar& a, FunctionSignature_Scalar& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionSignature_Scalar* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionSignature_Scalar* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionSignature_Scalar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionSignature_Scalar>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionSignature_Scalar& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const FunctionSignature_Scalar& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionSignature_Scalar* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FunctionSignature.Scalar";
+  }
+  protected:
+  explicit FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kArgumentsFieldNumber = 2,
+    kNameFieldNumber = 3,
+    kImplementationsFieldNumber = 12,
+    kDescriptionFieldNumber = 4,
+    kOutputTypeFieldNumber = 9,
+    kDeterministicFieldNumber = 7,
+    kSessionDependentFieldNumber = 8,
+    kVariadicFieldNumber = 10,
+    kNormalFieldNumber = 11,
+  };
+  // repeated .substrait.FunctionSignature.Argument arguments = 2;
+  int arguments_size() const;
+  private:
+  int _internal_arguments_size() const;
+  public:
+  void clear_arguments();
+  ::substrait::FunctionSignature_Argument* mutable_arguments(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >*
+      mutable_arguments();
+  private:
+  const ::substrait::FunctionSignature_Argument& _internal_arguments(int index) const;
+  ::substrait::FunctionSignature_Argument* _internal_add_arguments();
+  public:
+  const ::substrait::FunctionSignature_Argument& arguments(int index) const;
+  ::substrait::FunctionSignature_Argument* add_arguments();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >&
+      arguments() const;
+
+  // repeated string name = 3;
+  int name_size() const;
+  private:
+  int _internal_name_size() const;
+  public:
+  void clear_name();
+  const std::string& name(int index) const;
+  std::string* mutable_name(int index);
+  void set_name(int index, const std::string& value);
+  void set_name(int index, std::string&& value);
+  void set_name(int index, const char* value);
+  void set_name(int index, const char* value, size_t size);
+  std::string* add_name();
+  void add_name(const std::string& value);
+  void add_name(std::string&& value);
+  void add_name(const char* value);
+  void add_name(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& name() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_name();
+  private:
+  const std::string& _internal_name(int index) const;
+  std::string* _internal_add_name();
+  public:
+
+  // repeated .substrait.FunctionSignature.Implementation implementations = 12;
+  int implementations_size() const;
+  private:
+  int _internal_implementations_size() const;
+  public:
+  void clear_implementations();
+  ::substrait::FunctionSignature_Implementation* mutable_implementations(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >*
+      mutable_implementations();
+  private:
+  const ::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const;
+  ::substrait::FunctionSignature_Implementation* _internal_add_implementations();
+  public:
+  const ::substrait::FunctionSignature_Implementation& implementations(int index) const;
+  ::substrait::FunctionSignature_Implementation* add_implementations();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >&
+      implementations() const;
+
+  // .substrait.FunctionSignature.Description description = 4;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const ::substrait::FunctionSignature_Description& description() const;
+  PROTOBUF_NODISCARD ::substrait::FunctionSignature_Description* release_description();
+  ::substrait::FunctionSignature_Description* mutable_description();
+  void set_allocated_description(::substrait::FunctionSignature_Description* description);
+  private:
+  const ::substrait::FunctionSignature_Description& _internal_description() const;
+  ::substrait::FunctionSignature_Description* _internal_mutable_description();
+  public:
+  void unsafe_arena_set_allocated_description(
+      ::substrait::FunctionSignature_Description* description);
+  ::substrait::FunctionSignature_Description* unsafe_arena_release_description();
+
+  // .substrait.DerivationExpression output_type = 9;
+  bool has_output_type() const;
+  private:
+  bool _internal_has_output_type() const;
+  public:
+  void clear_output_type();
+  const ::substrait::DerivationExpression& output_type() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_output_type();
+  ::substrait::DerivationExpression* mutable_output_type();
+  void set_allocated_output_type(::substrait::DerivationExpression* output_type);
+  private:
+  const ::substrait::DerivationExpression& _internal_output_type() const;
+  ::substrait::DerivationExpression* _internal_mutable_output_type();
+  public:
+  void unsafe_arena_set_allocated_output_type(
+      ::substrait::DerivationExpression* output_type);
+  ::substrait::DerivationExpression* unsafe_arena_release_output_type();
+
+  // bool deterministic = 7;
+  void clear_deterministic();
+  bool deterministic() const;
+  void set_deterministic(bool value);
+  private:
+  bool _internal_deterministic() const;
+  void _internal_set_deterministic(bool value);
+  public:
+
+  // bool session_dependent = 8;
+  void clear_session_dependent();
+  bool session_dependent() const;
+  void set_session_dependent(bool value);
+  private:
+  bool _internal_session_dependent() const;
+  void _internal_set_session_dependent(bool value);
+  public:
+
+  // .substrait.FunctionSignature.FinalArgVariadic variadic = 10;
+  bool has_variadic() const;
+  private:
+  bool _internal_has_variadic() const;
+  public:
+  void clear_variadic();
+  const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const;
+  PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgVariadic* release_variadic();
+  ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic();
+  void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic);
+  private:
+  const ::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const;
+  ::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic();
+  public:
+  void unsafe_arena_set_allocated_variadic(
+      ::substrait::FunctionSignature_FinalArgVariadic* variadic);
+  ::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic();
+
+  // .substrait.FunctionSignature.FinalArgNormal normal = 11;
+  bool has_normal() const;
+  private:
+  bool _internal_has_normal() const;
+  public:
+  void clear_normal();
+  const ::substrait::FunctionSignature_FinalArgNormal& normal() const;
+  PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgNormal* release_normal();
+  ::substrait::FunctionSignature_FinalArgNormal* mutable_normal();
+  void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal);
+  private:
+  const ::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const;
+  ::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal();
+  public:
+  void unsafe_arena_set_allocated_normal(
+      ::substrait::FunctionSignature_FinalArgNormal* normal);
+  ::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal();
+
+  void clear_final_variable_behavior();
+  FinalVariableBehaviorCase final_variable_behavior_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Scalar)
+ private:
+  class _Internal;
+  void set_has_variadic();
+  void set_has_normal();
+
+  inline bool has_final_variable_behavior() const;
+  inline void clear_has_final_variable_behavior();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument > arguments_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> name_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation > implementations_;
+  ::substrait::FunctionSignature_Description* description_;
+  ::substrait::DerivationExpression* output_type_;
+  bool deterministic_;
+  bool session_dependent_;
+  union FinalVariableBehaviorUnion {
+    constexpr FinalVariableBehaviorUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::FunctionSignature_FinalArgVariadic* variadic_;
+    ::substrait::FunctionSignature_FinalArgNormal* normal_;
+  } final_variable_behavior_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionSignature_Aggregate final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Aggregate) */ {
+ public:
+  inline FunctionSignature_Aggregate() : FunctionSignature_Aggregate(nullptr) {}
+  ~FunctionSignature_Aggregate() override;
+  explicit constexpr FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionSignature_Aggregate(const FunctionSignature_Aggregate& from);
+  FunctionSignature_Aggregate(FunctionSignature_Aggregate&& from) noexcept
+    : FunctionSignature_Aggregate() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionSignature_Aggregate& operator=(const FunctionSignature_Aggregate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionSignature_Aggregate& operator=(FunctionSignature_Aggregate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionSignature_Aggregate& default_instance() {
+    return *internal_default_instance();
+  }
+  enum FinalVariableBehaviorCase {
+    kVariadic = 10,
+    kNormal = 11,
+    FINAL_VARIABLE_BEHAVIOR_NOT_SET = 0,
+  };
+
+  static inline const FunctionSignature_Aggregate* internal_default_instance() {
+    return reinterpret_cast<const FunctionSignature_Aggregate*>(
+               &_FunctionSignature_Aggregate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(FunctionSignature_Aggregate& a, FunctionSignature_Aggregate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionSignature_Aggregate* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionSignature_Aggregate* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionSignature_Aggregate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionSignature_Aggregate>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionSignature_Aggregate& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const FunctionSignature_Aggregate& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionSignature_Aggregate* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FunctionSignature.Aggregate";
+  }
+  protected:
+  explicit FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kArgumentsFieldNumber = 2,
+    kImplementationsFieldNumber = 15,
+    kNameFieldNumber = 3,
+    kDescriptionFieldNumber = 4,
+    kOutputTypeFieldNumber = 9,
+    kIntermediateTypeFieldNumber = 13,
+    kDeterministicFieldNumber = 7,
+    kSessionDependentFieldNumber = 8,
+    kOrderedFieldNumber = 14,
+    kMaxSetFieldNumber = 12,
+    kVariadicFieldNumber = 10,
+    kNormalFieldNumber = 11,
+  };
+  // repeated .substrait.FunctionSignature.Argument arguments = 2;
+  int arguments_size() const;
+  private:
+  int _internal_arguments_size() const;
+  public:
+  void clear_arguments();
+  ::substrait::FunctionSignature_Argument* mutable_arguments(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >*
+      mutable_arguments();
+  private:
+  const ::substrait::FunctionSignature_Argument& _internal_arguments(int index) const;
+  ::substrait::FunctionSignature_Argument* _internal_add_arguments();
+  public:
+  const ::substrait::FunctionSignature_Argument& arguments(int index) const;
+  ::substrait::FunctionSignature_Argument* add_arguments();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >&
+      arguments() const;
+
+  // repeated .substrait.FunctionSignature.Implementation implementations = 15;
+  int implementations_size() const;
+  private:
+  int _internal_implementations_size() const;
+  public:
+  void clear_implementations();
+  ::substrait::FunctionSignature_Implementation* mutable_implementations(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >*
+      mutable_implementations();
+  private:
+  const ::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const;
+  ::substrait::FunctionSignature_Implementation* _internal_add_implementations();
+  public:
+  const ::substrait::FunctionSignature_Implementation& implementations(int index) const;
+  ::substrait::FunctionSignature_Implementation* add_implementations();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >&
+      implementations() const;
+
+  // string name = 3;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // .substrait.FunctionSignature.Description description = 4;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const ::substrait::FunctionSignature_Description& description() const;
+  PROTOBUF_NODISCARD ::substrait::FunctionSignature_Description* release_description();
+  ::substrait::FunctionSignature_Description* mutable_description();
+  void set_allocated_description(::substrait::FunctionSignature_Description* description);
+  private:
+  const ::substrait::FunctionSignature_Description& _internal_description() const;
+  ::substrait::FunctionSignature_Description* _internal_mutable_description();
+  public:
+  void unsafe_arena_set_allocated_description(
+      ::substrait::FunctionSignature_Description* description);
+  ::substrait::FunctionSignature_Description* unsafe_arena_release_description();
+
+  // .substrait.DerivationExpression output_type = 9;
+  bool has_output_type() const;
+  private:
+  bool _internal_has_output_type() const;
+  public:
+  void clear_output_type();
+  const ::substrait::DerivationExpression& output_type() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_output_type();
+  ::substrait::DerivationExpression* mutable_output_type();
+  void set_allocated_output_type(::substrait::DerivationExpression* output_type);
+  private:
+  const ::substrait::DerivationExpression& _internal_output_type() const;
+  ::substrait::DerivationExpression* _internal_mutable_output_type();
+  public:
+  void unsafe_arena_set_allocated_output_type(
+      ::substrait::DerivationExpression* output_type);
+  ::substrait::DerivationExpression* unsafe_arena_release_output_type();
+
+  // .substrait.Type intermediate_type = 13;
+  bool has_intermediate_type() const;
+  private:
+  bool _internal_has_intermediate_type() const;
+  public:
+  void clear_intermediate_type();
+  const ::substrait::Type& intermediate_type() const;
+  PROTOBUF_NODISCARD ::substrait::Type* release_intermediate_type();
+  ::substrait::Type* mutable_intermediate_type();
+  void set_allocated_intermediate_type(::substrait::Type* intermediate_type);
+  private:
+  const ::substrait::Type& _internal_intermediate_type() const;
+  ::substrait::Type* _internal_mutable_intermediate_type();
+  public:
+  void unsafe_arena_set_allocated_intermediate_type(
+      ::substrait::Type* intermediate_type);
+  ::substrait::Type* unsafe_arena_release_intermediate_type();
+
+  // bool deterministic = 7;
+  void clear_deterministic();
+  bool deterministic() const;
+  void set_deterministic(bool value);
+  private:
+  bool _internal_deterministic() const;
+  void _internal_set_deterministic(bool value);
+  public:
+
+  // bool session_dependent = 8;
+  void clear_session_dependent();
+  bool session_dependent() const;
+  void set_session_dependent(bool value);
+  private:
+  bool _internal_session_dependent() const;
+  void _internal_set_session_dependent(bool value);
+  public:
+
+  // bool ordered = 14;
+  void clear_ordered();
+  bool ordered() const;
+  void set_ordered(bool value);
+  private:
+  bool _internal_ordered() const;
+  void _internal_set_ordered(bool value);
+  public:
+
+  // uint64 max_set = 12;
+  void clear_max_set();
+  uint64_t max_set() const;
+  void set_max_set(uint64_t value);
+  private:
+  uint64_t _internal_max_set() const;
+  void _internal_set_max_set(uint64_t value);
+  public:
+
+  // .substrait.FunctionSignature.FinalArgVariadic variadic = 10;
+  bool has_variadic() const;
+  private:
+  bool _internal_has_variadic() const;
+  public:
+  void clear_variadic();
+  const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const;
+  PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgVariadic* release_variadic();
+  ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic();
+  void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic);
+  private:
+  const ::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const;
+  ::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic();
+  public:
+  void unsafe_arena_set_allocated_variadic(
+      ::substrait::FunctionSignature_FinalArgVariadic* variadic);
+  ::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic();
+
+  // .substrait.FunctionSignature.FinalArgNormal normal = 11;
+  bool has_normal() const;
+  private:
+  bool _internal_has_normal() const;
+  public:
+  void clear_normal();
+  const ::substrait::FunctionSignature_FinalArgNormal& normal() const;
+  PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgNormal* release_normal();
+  ::substrait::FunctionSignature_FinalArgNormal* mutable_normal();
+  void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal);
+  private:
+  const ::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const;
+  ::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal();
+  public:
+  void unsafe_arena_set_allocated_normal(
+      ::substrait::FunctionSignature_FinalArgNormal* normal);
+  ::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal();
+
+  void clear_final_variable_behavior();
+  FinalVariableBehaviorCase final_variable_behavior_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Aggregate)
+ private:
+  class _Internal;
+  void set_has_variadic();
+  void set_has_normal();
+
+  inline bool has_final_variable_behavior() const;
+  inline void clear_has_final_variable_behavior();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument > arguments_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation > implementations_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  ::substrait::FunctionSignature_Description* description_;
+  ::substrait::DerivationExpression* output_type_;
+  ::substrait::Type* intermediate_type_;
+  bool deterministic_;
+  bool session_dependent_;
+  bool ordered_;
+  uint64_t max_set_;
+  union FinalVariableBehaviorUnion {
+    constexpr FinalVariableBehaviorUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::FunctionSignature_FinalArgVariadic* variadic_;
+    ::substrait::FunctionSignature_FinalArgNormal* normal_;
+  } final_variable_behavior_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionSignature_Window final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Window) */ {
+ public:
+  inline FunctionSignature_Window() : FunctionSignature_Window(nullptr) {}
+  ~FunctionSignature_Window() override;
+  explicit constexpr FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionSignature_Window(const FunctionSignature_Window& from);
+  FunctionSignature_Window(FunctionSignature_Window&& from) noexcept
+    : FunctionSignature_Window() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionSignature_Window& operator=(const FunctionSignature_Window& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionSignature_Window& operator=(FunctionSignature_Window&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionSignature_Window& default_instance() {
+    return *internal_default_instance();
+  }
+  enum FinalVariableBehaviorCase {
+    kVariadic = 16,
+    kNormal = 17,
+    FINAL_VARIABLE_BEHAVIOR_NOT_SET = 0,
+  };
+
+  static inline const FunctionSignature_Window* internal_default_instance() {
+    return reinterpret_cast<const FunctionSignature_Window*>(
+               &_FunctionSignature_Window_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(FunctionSignature_Window& a, FunctionSignature_Window& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionSignature_Window* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionSignature_Window* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionSignature_Window* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionSignature_Window>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionSignature_Window& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const FunctionSignature_Window& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionSignature_Window* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FunctionSignature.Window";
+  }
+  protected:
+  explicit FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FunctionSignature_Window_WindowType WindowType;
+  static constexpr WindowType WINDOW_TYPE_UNSPECIFIED =
+    FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED;
+  static constexpr WindowType WINDOW_TYPE_STREAMING =
+    FunctionSignature_Window_WindowType_WINDOW_TYPE_STREAMING;
+  static constexpr WindowType WINDOW_TYPE_PARTITION =
+    FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION;
+  static inline bool WindowType_IsValid(int value) {
+    return FunctionSignature_Window_WindowType_IsValid(value);
+  }
+  static constexpr WindowType WindowType_MIN =
+    FunctionSignature_Window_WindowType_WindowType_MIN;
+  static constexpr WindowType WindowType_MAX =
+    FunctionSignature_Window_WindowType_WindowType_MAX;
+  static constexpr int WindowType_ARRAYSIZE =
+    FunctionSignature_Window_WindowType_WindowType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  WindowType_descriptor() {
+    return FunctionSignature_Window_WindowType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& WindowType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, WindowType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function WindowType_Name.");
+    return FunctionSignature_Window_WindowType_Name(enum_t_value);
+  }
+  static inline bool WindowType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      WindowType* value) {
+    return FunctionSignature_Window_WindowType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kArgumentsFieldNumber = 2,
+    kNameFieldNumber = 3,
+    kImplementationsFieldNumber = 15,
+    kDescriptionFieldNumber = 4,
+    kIntermediateTypeFieldNumber = 9,
+    kOutputTypeFieldNumber = 10,
+    kDeterministicFieldNumber = 7,
+    kSessionDependentFieldNumber = 8,
+    kOrderedFieldNumber = 11,
+    kWindowTypeFieldNumber = 14,
+    kMaxSetFieldNumber = 12,
+    kVariadicFieldNumber = 16,
+    kNormalFieldNumber = 17,
+  };
+  // repeated .substrait.FunctionSignature.Argument arguments = 2;
+  int arguments_size() const;
+  private:
+  int _internal_arguments_size() const;
+  public:
+  void clear_arguments();
+  ::substrait::FunctionSignature_Argument* mutable_arguments(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >*
+      mutable_arguments();
+  private:
+  const ::substrait::FunctionSignature_Argument& _internal_arguments(int index) const;
+  ::substrait::FunctionSignature_Argument* _internal_add_arguments();
+  public:
+  const ::substrait::FunctionSignature_Argument& arguments(int index) const;
+  ::substrait::FunctionSignature_Argument* add_arguments();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >&
+      arguments() const;
+
+  // repeated string name = 3;
+  int name_size() const;
+  private:
+  int _internal_name_size() const;
+  public:
+  void clear_name();
+  const std::string& name(int index) const;
+  std::string* mutable_name(int index);
+  void set_name(int index, const std::string& value);
+  void set_name(int index, std::string&& value);
+  void set_name(int index, const char* value);
+  void set_name(int index, const char* value, size_t size);
+  std::string* add_name();
+  void add_name(const std::string& value);
+  void add_name(std::string&& value);
+  void add_name(const char* value);
+  void add_name(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& name() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_name();
+  private:
+  const std::string& _internal_name(int index) const;
+  std::string* _internal_add_name();
+  public:
+
+  // repeated .substrait.FunctionSignature.Implementation implementations = 15;
+  int implementations_size() const;
+  private:
+  int _internal_implementations_size() const;
+  public:
+  void clear_implementations();
+  ::substrait::FunctionSignature_Implementation* mutable_implementations(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >*
+      mutable_implementations();
+  private:
+  const ::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const;
+  ::substrait::FunctionSignature_Implementation* _internal_add_implementations();
+  public:
+  const ::substrait::FunctionSignature_Implementation& implementations(int index) const;
+  ::substrait::FunctionSignature_Implementation* add_implementations();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >&
+      implementations() const;
+
+  // .substrait.FunctionSignature.Description description = 4;
+  bool has_description() const;
+  private:
+  bool _internal_has_description() const;
+  public:
+  void clear_description();
+  const ::substrait::FunctionSignature_Description& description() const;
+  PROTOBUF_NODISCARD ::substrait::FunctionSignature_Description* release_description();
+  ::substrait::FunctionSignature_Description* mutable_description();
+  void set_allocated_description(::substrait::FunctionSignature_Description* description);
+  private:
+  const ::substrait::FunctionSignature_Description& _internal_description() const;
+  ::substrait::FunctionSignature_Description* _internal_mutable_description();
+  public:
+  void unsafe_arena_set_allocated_description(
+      ::substrait::FunctionSignature_Description* description);
+  ::substrait::FunctionSignature_Description* unsafe_arena_release_description();
+
+  // .substrait.DerivationExpression intermediate_type = 9;
+  bool has_intermediate_type() const;
+  private:
+  bool _internal_has_intermediate_type() const;
+  public:
+  void clear_intermediate_type();
+  const ::substrait::DerivationExpression& intermediate_type() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_intermediate_type();
+  ::substrait::DerivationExpression* mutable_intermediate_type();
+  void set_allocated_intermediate_type(::substrait::DerivationExpression* intermediate_type);
+  private:
+  const ::substrait::DerivationExpression& _internal_intermediate_type() const;
+  ::substrait::DerivationExpression* _internal_mutable_intermediate_type();
+  public:
+  void unsafe_arena_set_allocated_intermediate_type(
+      ::substrait::DerivationExpression* intermediate_type);
+  ::substrait::DerivationExpression* unsafe_arena_release_intermediate_type();
+
+  // .substrait.DerivationExpression output_type = 10;
+  bool has_output_type() const;
+  private:
+  bool _internal_has_output_type() const;
+  public:
+  void clear_output_type();
+  const ::substrait::DerivationExpression& output_type() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_output_type();
+  ::substrait::DerivationExpression* mutable_output_type();
+  void set_allocated_output_type(::substrait::DerivationExpression* output_type);
+  private:
+  const ::substrait::DerivationExpression& _internal_output_type() const;
+  ::substrait::DerivationExpression* _internal_mutable_output_type();
+  public:
+  void unsafe_arena_set_allocated_output_type(
+      ::substrait::DerivationExpression* output_type);
+  ::substrait::DerivationExpression* unsafe_arena_release_output_type();
+
+  // bool deterministic = 7;
+  void clear_deterministic();
+  bool deterministic() const;
+  void set_deterministic(bool value);
+  private:
+  bool _internal_deterministic() const;
+  void _internal_set_deterministic(bool value);
+  public:
+
+  // bool session_dependent = 8;
+  void clear_session_dependent();
+  bool session_dependent() const;
+  void set_session_dependent(bool value);
+  private:
+  bool _internal_session_dependent() const;
+  void _internal_set_session_dependent(bool value);
+  public:
+
+  // bool ordered = 11;
+  void clear_ordered();
+  bool ordered() const;
+  void set_ordered(bool value);
+  private:
+  bool _internal_ordered() const;
+  void _internal_set_ordered(bool value);
+  public:
+
+  // .substrait.FunctionSignature.Window.WindowType window_type = 14;
+  void clear_window_type();
+  ::substrait::FunctionSignature_Window_WindowType window_type() const;
+  void set_window_type(::substrait::FunctionSignature_Window_WindowType value);
+  private:
+  ::substrait::FunctionSignature_Window_WindowType _internal_window_type() const;
+  void _internal_set_window_type(::substrait::FunctionSignature_Window_WindowType value);
+  public:
+
+  // uint64 max_set = 12;
+  void clear_max_set();
+  uint64_t max_set() const;
+  void set_max_set(uint64_t value);
+  private:
+  uint64_t _internal_max_set() const;
+  void _internal_set_max_set(uint64_t value);
+  public:
+
+  // .substrait.FunctionSignature.FinalArgVariadic variadic = 16;
+  bool has_variadic() const;
+  private:
+  bool _internal_has_variadic() const;
+  public:
+  void clear_variadic();
+  const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const;
+  PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgVariadic* release_variadic();
+  ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic();
+  void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic);
+  private:
+  const ::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const;
+  ::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic();
+  public:
+  void unsafe_arena_set_allocated_variadic(
+      ::substrait::FunctionSignature_FinalArgVariadic* variadic);
+  ::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic();
+
+  // .substrait.FunctionSignature.FinalArgNormal normal = 17;
+  bool has_normal() const;
+  private:
+  bool _internal_has_normal() const;
+  public:
+  void clear_normal();
+  const ::substrait::FunctionSignature_FinalArgNormal& normal() const;
+  PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgNormal* release_normal();
+  ::substrait::FunctionSignature_FinalArgNormal* mutable_normal();
+  void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal);
+  private:
+  const ::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const;
+  ::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal();
+  public:
+  void unsafe_arena_set_allocated_normal(
+      ::substrait::FunctionSignature_FinalArgNormal* normal);
+  ::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal();
+
+  void clear_final_variable_behavior();
+  FinalVariableBehaviorCase final_variable_behavior_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Window)
+ private:
+  class _Internal;
+  void set_has_variadic();
+  void set_has_normal();
+
+  inline bool has_final_variable_behavior() const;
+  inline void clear_has_final_variable_behavior();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument > arguments_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> name_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation > implementations_;
+  ::substrait::FunctionSignature_Description* description_;
+  ::substrait::DerivationExpression* intermediate_type_;
+  ::substrait::DerivationExpression* output_type_;
+  bool deterministic_;
+  bool session_dependent_;
+  bool ordered_;
+  int window_type_;
+  uint64_t max_set_;
+  union FinalVariableBehaviorUnion {
+    constexpr FinalVariableBehaviorUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::FunctionSignature_FinalArgVariadic* variadic_;
+    ::substrait::FunctionSignature_FinalArgNormal* normal_;
+  } final_variable_behavior_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionSignature_Description final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Description) */ {
+ public:
+  inline FunctionSignature_Description() : FunctionSignature_Description(nullptr) {}
+  ~FunctionSignature_Description() override;
+  explicit constexpr FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionSignature_Description(const FunctionSignature_Description& from);
+  FunctionSignature_Description(FunctionSignature_Description&& from) noexcept
+    : FunctionSignature_Description() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionSignature_Description& operator=(const FunctionSignature_Description& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionSignature_Description& operator=(FunctionSignature_Description&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionSignature_Description& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FunctionSignature_Description* internal_default_instance() {
+    return reinterpret_cast<const FunctionSignature_Description*>(
+               &_FunctionSignature_Description_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(FunctionSignature_Description& a, FunctionSignature_Description& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionSignature_Description* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionSignature_Description* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionSignature_Description* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionSignature_Description>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionSignature_Description& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const FunctionSignature_Description& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionSignature_Description* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FunctionSignature.Description";
+  }
+  protected:
+  explicit FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLanguageFieldNumber = 1,
+    kBodyFieldNumber = 2,
+  };
+  // string language = 1;
+  void clear_language();
+  const std::string& language() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_language(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_language();
+  PROTOBUF_NODISCARD std::string* release_language();
+  void set_allocated_language(std::string* language);
+  private:
+  const std::string& _internal_language() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_language(const std::string& value);
+  std::string* _internal_mutable_language();
+  public:
+
+  // string body = 2;
+  void clear_body();
+  const std::string& body() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_body(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_body();
+  PROTOBUF_NODISCARD std::string* release_body();
+  void set_allocated_body(std::string* body);
+  private:
+  const std::string& _internal_body() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value);
+  std::string* _internal_mutable_body();
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Description)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr language_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionSignature_Implementation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Implementation) */ {
+ public:
+  inline FunctionSignature_Implementation() : FunctionSignature_Implementation(nullptr) {}
+  ~FunctionSignature_Implementation() override;
+  explicit constexpr FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionSignature_Implementation(const FunctionSignature_Implementation& from);
+  FunctionSignature_Implementation(FunctionSignature_Implementation&& from) noexcept
+    : FunctionSignature_Implementation() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionSignature_Implementation& operator=(const FunctionSignature_Implementation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionSignature_Implementation& operator=(FunctionSignature_Implementation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionSignature_Implementation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FunctionSignature_Implementation* internal_default_instance() {
+    return reinterpret_cast<const FunctionSignature_Implementation*>(
+               &_FunctionSignature_Implementation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(FunctionSignature_Implementation& a, FunctionSignature_Implementation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionSignature_Implementation* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionSignature_Implementation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionSignature_Implementation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionSignature_Implementation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionSignature_Implementation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const FunctionSignature_Implementation& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionSignature_Implementation* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FunctionSignature.Implementation";
+  }
+  protected:
+  explicit FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FunctionSignature_Implementation_Type Type;
+  static constexpr Type TYPE_UNSPECIFIED =
+    FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED;
+  static constexpr Type TYPE_WEB_ASSEMBLY =
+    FunctionSignature_Implementation_Type_TYPE_WEB_ASSEMBLY;
+  static constexpr Type TYPE_TRINO_JAR =
+    FunctionSignature_Implementation_Type_TYPE_TRINO_JAR;
+  static inline bool Type_IsValid(int value) {
+    return FunctionSignature_Implementation_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    FunctionSignature_Implementation_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    FunctionSignature_Implementation_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    FunctionSignature_Implementation_Type_Type_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Type_descriptor() {
+    return FunctionSignature_Implementation_Type_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return FunctionSignature_Implementation_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return FunctionSignature_Implementation_Type_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kUriFieldNumber = 2,
+    kTypeFieldNumber = 1,
+  };
+  // string uri = 2;
+  void clear_uri();
+  const std::string& uri() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_uri(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_uri();
+  PROTOBUF_NODISCARD std::string* release_uri();
+  void set_allocated_uri(std::string* uri);
+  private:
+  const std::string& _internal_uri() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri(const std::string& value);
+  std::string* _internal_mutable_uri();
+  public:
+
+  // .substrait.FunctionSignature.Implementation.Type type = 1;
+  void clear_type();
+  ::substrait::FunctionSignature_Implementation_Type type() const;
+  void set_type(::substrait::FunctionSignature_Implementation_Type value);
+  private:
+  ::substrait::FunctionSignature_Implementation_Type _internal_type() const;
+  void _internal_set_type(::substrait::FunctionSignature_Implementation_Type value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Implementation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_;
+  int type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionSignature_Argument_ValueArgument final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.ValueArgument) */ {
+ public:
+  inline FunctionSignature_Argument_ValueArgument() : FunctionSignature_Argument_ValueArgument(nullptr) {}
+  ~FunctionSignature_Argument_ValueArgument() override;
+  explicit constexpr FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionSignature_Argument_ValueArgument(const FunctionSignature_Argument_ValueArgument& from);
+  FunctionSignature_Argument_ValueArgument(FunctionSignature_Argument_ValueArgument&& from) noexcept
+    : FunctionSignature_Argument_ValueArgument() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionSignature_Argument_ValueArgument& operator=(const FunctionSignature_Argument_ValueArgument& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionSignature_Argument_ValueArgument& operator=(FunctionSignature_Argument_ValueArgument&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionSignature_Argument_ValueArgument& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FunctionSignature_Argument_ValueArgument* internal_default_instance() {
+    return reinterpret_cast<const FunctionSignature_Argument_ValueArgument*>(
+               &_FunctionSignature_Argument_ValueArgument_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(FunctionSignature_Argument_ValueArgument& a, FunctionSignature_Argument_ValueArgument& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionSignature_Argument_ValueArgument* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionSignature_Argument_ValueArgument* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionSignature_Argument_ValueArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionSignature_Argument_ValueArgument>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionSignature_Argument_ValueArgument& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const FunctionSignature_Argument_ValueArgument& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionSignature_Argument_ValueArgument* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FunctionSignature.Argument.ValueArgument";
+  }
+  protected:
+  explicit FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeFieldNumber = 1,
+    kConstantFieldNumber = 2,
+  };
+  // .substrait.ParameterizedType type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  const ::substrait::ParameterizedType& type() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_type();
+  ::substrait::ParameterizedType* mutable_type();
+  void set_allocated_type(::substrait::ParameterizedType* type);
+  private:
+  const ::substrait::ParameterizedType& _internal_type() const;
+  ::substrait::ParameterizedType* _internal_mutable_type();
+  public:
+  void unsafe_arena_set_allocated_type(
+      ::substrait::ParameterizedType* type);
+  ::substrait::ParameterizedType* unsafe_arena_release_type();
+
+  // bool constant = 2;
+  void clear_constant();
+  bool constant() const;
+  void set_constant(bool value);
+  private:
+  bool _internal_constant() const;
+  void _internal_set_constant(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument.ValueArgument)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::ParameterizedType* type_;
+  bool constant_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionSignature_Argument_TypeArgument final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.TypeArgument) */ {
+ public:
+  inline FunctionSignature_Argument_TypeArgument() : FunctionSignature_Argument_TypeArgument(nullptr) {}
+  ~FunctionSignature_Argument_TypeArgument() override;
+  explicit constexpr FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionSignature_Argument_TypeArgument(const FunctionSignature_Argument_TypeArgument& from);
+  FunctionSignature_Argument_TypeArgument(FunctionSignature_Argument_TypeArgument&& from) noexcept
+    : FunctionSignature_Argument_TypeArgument() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionSignature_Argument_TypeArgument& operator=(const FunctionSignature_Argument_TypeArgument& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionSignature_Argument_TypeArgument& operator=(FunctionSignature_Argument_TypeArgument&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionSignature_Argument_TypeArgument& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FunctionSignature_Argument_TypeArgument* internal_default_instance() {
+    return reinterpret_cast<const FunctionSignature_Argument_TypeArgument*>(
+               &_FunctionSignature_Argument_TypeArgument_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(FunctionSignature_Argument_TypeArgument& a, FunctionSignature_Argument_TypeArgument& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionSignature_Argument_TypeArgument* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionSignature_Argument_TypeArgument* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionSignature_Argument_TypeArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionSignature_Argument_TypeArgument>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionSignature_Argument_TypeArgument& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const FunctionSignature_Argument_TypeArgument& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionSignature_Argument_TypeArgument* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FunctionSignature.Argument.TypeArgument";
+  }
+  protected:
+  explicit FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeFieldNumber = 1,
+  };
+  // .substrait.ParameterizedType type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  const ::substrait::ParameterizedType& type() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_type();
+  ::substrait::ParameterizedType* mutable_type();
+  void set_allocated_type(::substrait::ParameterizedType* type);
+  private:
+  const ::substrait::ParameterizedType& _internal_type() const;
+  ::substrait::ParameterizedType* _internal_mutable_type();
+  public:
+  void unsafe_arena_set_allocated_type(
+      ::substrait::ParameterizedType* type);
+  ::substrait::ParameterizedType* unsafe_arena_release_type();
+
+  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument.TypeArgument)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::ParameterizedType* type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionSignature_Argument_EnumArgument final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.EnumArgument) */ {
+ public:
+  inline FunctionSignature_Argument_EnumArgument() : FunctionSignature_Argument_EnumArgument(nullptr) {}
+  ~FunctionSignature_Argument_EnumArgument() override;
+  explicit constexpr FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionSignature_Argument_EnumArgument(const FunctionSignature_Argument_EnumArgument& from);
+  FunctionSignature_Argument_EnumArgument(FunctionSignature_Argument_EnumArgument&& from) noexcept
+    : FunctionSignature_Argument_EnumArgument() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionSignature_Argument_EnumArgument& operator=(const FunctionSignature_Argument_EnumArgument& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionSignature_Argument_EnumArgument& operator=(FunctionSignature_Argument_EnumArgument&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionSignature_Argument_EnumArgument& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FunctionSignature_Argument_EnumArgument* internal_default_instance() {
+    return reinterpret_cast<const FunctionSignature_Argument_EnumArgument*>(
+               &_FunctionSignature_Argument_EnumArgument_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(FunctionSignature_Argument_EnumArgument& a, FunctionSignature_Argument_EnumArgument& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionSignature_Argument_EnumArgument* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionSignature_Argument_EnumArgument* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionSignature_Argument_EnumArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionSignature_Argument_EnumArgument>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionSignature_Argument_EnumArgument& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const FunctionSignature_Argument_EnumArgument& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionSignature_Argument_EnumArgument* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FunctionSignature.Argument.EnumArgument";
+  }
+  protected:
+  explicit FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOptionsFieldNumber = 1,
+    kOptionalFieldNumber = 2,
+  };
+  // repeated string options = 1;
+  int options_size() const;
+  private:
+  int _internal_options_size() const;
+  public:
+  void clear_options();
+  const std::string& options(int index) const;
+  std::string* mutable_options(int index);
+  void set_options(int index, const std::string& value);
+  void set_options(int index, std::string&& value);
+  void set_options(int index, const char* value);
+  void set_options(int index, const char* value, size_t size);
+  std::string* add_options();
+  void add_options(const std::string& value);
+  void add_options(std::string&& value);
+  void add_options(const char* value);
+  void add_options(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& options() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_options();
+  private:
+  const std::string& _internal_options(int index) const;
+  std::string* _internal_add_options();
+  public:
+
+  // bool optional = 2;
+  void clear_optional();
+  bool optional() const;
+  void set_optional(bool value);
+  private:
+  bool _internal_optional() const;
+  void _internal_set_optional(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument.EnumArgument)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> options_;
+  bool optional_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionSignature_Argument final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument) */ {
+ public:
+  inline FunctionSignature_Argument() : FunctionSignature_Argument(nullptr) {}
+  ~FunctionSignature_Argument() override;
+  explicit constexpr FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionSignature_Argument(const FunctionSignature_Argument& from);
+  FunctionSignature_Argument(FunctionSignature_Argument&& from) noexcept
+    : FunctionSignature_Argument() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionSignature_Argument& operator=(const FunctionSignature_Argument& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionSignature_Argument& operator=(FunctionSignature_Argument&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionSignature_Argument& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ArgumentKindCase {
+    kValue = 2,
+    kType = 3,
+    kEnum = 4,
+    ARGUMENT_KIND_NOT_SET = 0,
+  };
+
+  static inline const FunctionSignature_Argument* internal_default_instance() {
+    return reinterpret_cast<const FunctionSignature_Argument*>(
+               &_FunctionSignature_Argument_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(FunctionSignature_Argument& a, FunctionSignature_Argument& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionSignature_Argument* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionSignature_Argument* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionSignature_Argument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionSignature_Argument>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FunctionSignature_Argument& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const FunctionSignature_Argument& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FunctionSignature_Argument* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FunctionSignature.Argument";
+  }
+  protected:
+  explicit FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FunctionSignature_Argument_ValueArgument ValueArgument;
+  typedef FunctionSignature_Argument_TypeArgument TypeArgument;
+  typedef FunctionSignature_Argument_EnumArgument EnumArgument;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kValueFieldNumber = 2,
+    kTypeFieldNumber = 3,
+    kEnumFieldNumber = 4,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // .substrait.FunctionSignature.Argument.ValueArgument value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const ::substrait::FunctionSignature_Argument_ValueArgument& value() const;
+  PROTOBUF_NODISCARD ::substrait::FunctionSignature_Argument_ValueArgument* release_value();
+  ::substrait::FunctionSignature_Argument_ValueArgument* mutable_value();
+  void set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value);
+  private:
+  const ::substrait::FunctionSignature_Argument_ValueArgument& _internal_value() const;
+  ::substrait::FunctionSignature_Argument_ValueArgument* _internal_mutable_value();
+  public:
+  void unsafe_arena_set_allocated_value(
+      ::substrait::FunctionSignature_Argument_ValueArgument* value);
+  ::substrait::FunctionSignature_Argument_ValueArgument* unsafe_arena_release_value();
+
+  // .substrait.FunctionSignature.Argument.TypeArgument type = 3;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  const ::substrait::FunctionSignature_Argument_TypeArgument& type() const;
+  PROTOBUF_NODISCARD ::substrait::FunctionSignature_Argument_TypeArgument* release_type();
+  ::substrait::FunctionSignature_Argument_TypeArgument* mutable_type();
+  void set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type);
+  private:
+  const ::substrait::FunctionSignature_Argument_TypeArgument& _internal_type() const;
+  ::substrait::FunctionSignature_Argument_TypeArgument* _internal_mutable_type();
+  public:
+  void unsafe_arena_set_allocated_type(
+      ::substrait::FunctionSignature_Argument_TypeArgument* type);
+  ::substrait::FunctionSignature_Argument_TypeArgument* unsafe_arena_release_type();
+
+  // .substrait.FunctionSignature.Argument.EnumArgument enum = 4;
+  bool has_enum_() const;
+  private:
+  bool _internal_has_enum_() const;
+  public:
+  void clear_enum_();
+  const ::substrait::FunctionSignature_Argument_EnumArgument& enum_() const;
+  PROTOBUF_NODISCARD ::substrait::FunctionSignature_Argument_EnumArgument* release_enum_();
+  ::substrait::FunctionSignature_Argument_EnumArgument* mutable_enum_();
+  void set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_);
+  private:
+  const ::substrait::FunctionSignature_Argument_EnumArgument& _internal_enum_() const;
+  ::substrait::FunctionSignature_Argument_EnumArgument* _internal_mutable_enum_();
+  public:
+  void unsafe_arena_set_allocated_enum_(
+      ::substrait::FunctionSignature_Argument_EnumArgument* enum_);
+  ::substrait::FunctionSignature_Argument_EnumArgument* unsafe_arena_release_enum_();
+
+  void clear_argument_kind();
+  ArgumentKindCase argument_kind_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument)
+ private:
+  class _Internal;
+  void set_has_value();
+  void set_has_type();
+  void set_has_enum_();
+
+  inline bool has_argument_kind() const;
+  inline void clear_has_argument_kind();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  union ArgumentKindUnion {
+    constexpr ArgumentKindUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::FunctionSignature_Argument_ValueArgument* value_;
+    ::substrait::FunctionSignature_Argument_TypeArgument* type_;
+    ::substrait::FunctionSignature_Argument_EnumArgument* enum__;
+  } argument_kind_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2ffunction_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FunctionSignature final :
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature) */ {
+ public:
+  inline FunctionSignature() : FunctionSignature(nullptr) {}
+  explicit constexpr FunctionSignature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FunctionSignature(const FunctionSignature& from);
+  FunctionSignature(FunctionSignature&& from) noexcept
+    : FunctionSignature() {
+    *this = ::std::move(from);
+  }
+
+  inline FunctionSignature& operator=(const FunctionSignature& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FunctionSignature& operator=(FunctionSignature&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FunctionSignature& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FunctionSignature* internal_default_instance() {
+    return reinterpret_cast<const FunctionSignature*>(
+               &_FunctionSignature_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(FunctionSignature& a, FunctionSignature& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FunctionSignature* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FunctionSignature* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FunctionSignature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FunctionSignature>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
+  inline void CopyFrom(const FunctionSignature& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
+  void MergeFrom(const FunctionSignature& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
+  }
+  public:
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FunctionSignature";
+  }
+  protected:
+  explicit FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef FunctionSignature_FinalArgVariadic FinalArgVariadic;
+  typedef FunctionSignature_FinalArgNormal FinalArgNormal;
+  typedef FunctionSignature_Scalar Scalar;
+  typedef FunctionSignature_Aggregate Aggregate;
+  typedef FunctionSignature_Window Window;
+  typedef FunctionSignature_Description Description;
+  typedef FunctionSignature_Implementation Implementation;
+  typedef FunctionSignature_Argument Argument;
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:substrait.FunctionSignature)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ffunction_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// FunctionSignature_FinalArgVariadic
+
+// int64 min_args = 1;
+inline void FunctionSignature_FinalArgVariadic::clear_min_args() {
+  min_args_ = int64_t{0};
+}
+inline int64_t FunctionSignature_FinalArgVariadic::_internal_min_args() const {
+  return min_args_;
+}
+inline int64_t FunctionSignature_FinalArgVariadic::min_args() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.min_args)
+  return _internal_min_args();
+}
+inline void FunctionSignature_FinalArgVariadic::_internal_set_min_args(int64_t value) {
+  
+  min_args_ = value;
+}
+inline void FunctionSignature_FinalArgVariadic::set_min_args(int64_t value) {
+  _internal_set_min_args(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.min_args)
+}
+
+// int64 max_args = 2;
+inline void FunctionSignature_FinalArgVariadic::clear_max_args() {
+  max_args_ = int64_t{0};
+}
+inline int64_t FunctionSignature_FinalArgVariadic::_internal_max_args() const {
+  return max_args_;
+}
+inline int64_t FunctionSignature_FinalArgVariadic::max_args() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.max_args)
+  return _internal_max_args();
+}
+inline void FunctionSignature_FinalArgVariadic::_internal_set_max_args(int64_t value) {
+  
+  max_args_ = value;
+}
+inline void FunctionSignature_FinalArgVariadic::set_max_args(int64_t value) {
+  _internal_set_max_args(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.max_args)
+}
+
+// .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3;
+inline void FunctionSignature_FinalArgVariadic::clear_consistency() {
+  consistency_ = 0;
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::_internal_consistency() const {
+  return static_cast< ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency >(consistency_);
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::consistency() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.consistency)
+  return _internal_consistency();
+}
+inline void FunctionSignature_FinalArgVariadic::_internal_set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value) {
+  
+  consistency_ = value;
+}
+inline void FunctionSignature_FinalArgVariadic::set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value) {
+  _internal_set_consistency(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.consistency)
+}
+
+// -------------------------------------------------------------------
+
+// FunctionSignature_FinalArgNormal
+
+// -------------------------------------------------------------------
+
+// FunctionSignature_Scalar
+
+// repeated .substrait.FunctionSignature.Argument arguments = 2;
+inline int FunctionSignature_Scalar::_internal_arguments_size() const {
+  return arguments_.size();
+}
+inline int FunctionSignature_Scalar::arguments_size() const {
+  return _internal_arguments_size();
+}
+inline void FunctionSignature_Scalar::clear_arguments() {
+  arguments_.Clear();
+}
+inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::mutable_arguments(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.arguments)
+  return arguments_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >*
+FunctionSignature_Scalar::mutable_arguments() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Scalar.arguments)
+  return &arguments_;
+}
+inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Scalar::_internal_arguments(int index) const {
+  return arguments_.Get(index);
+}
+inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Scalar::arguments(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.arguments)
+  return _internal_arguments(index);
+}
+inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::_internal_add_arguments() {
+  return arguments_.Add();
+}
+inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::add_arguments() {
+  ::substrait::FunctionSignature_Argument* _add = _internal_add_arguments();
+  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.arguments)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >&
+FunctionSignature_Scalar::arguments() const {
+  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.arguments)
+  return arguments_;
+}
+
+// repeated string name = 3;
+inline int FunctionSignature_Scalar::_internal_name_size() const {
+  return name_.size();
+}
+inline int FunctionSignature_Scalar::name_size() const {
+  return _internal_name_size();
+}
+inline void FunctionSignature_Scalar::clear_name() {
+  name_.Clear();
+}
+inline std::string* FunctionSignature_Scalar::add_name() {
+  std::string* _s = _internal_add_name();
+  // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Scalar.name)
+  return _s;
+}
+inline const std::string& FunctionSignature_Scalar::_internal_name(int index) const {
+  return name_.Get(index);
+}
+inline const std::string& FunctionSignature_Scalar::name(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.name)
+  return _internal_name(index);
+}
+inline std::string* FunctionSignature_Scalar::mutable_name(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.name)
+  return name_.Mutable(index);
+}
+inline void FunctionSignature_Scalar::set_name(int index, const std::string& value) {
+  name_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.name)
+}
+inline void FunctionSignature_Scalar::set_name(int index, std::string&& value) {
+  name_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.name)
+}
+inline void FunctionSignature_Scalar::set_name(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  name_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.FunctionSignature.Scalar.name)
+}
+inline void FunctionSignature_Scalar::set_name(int index, const char* value, size_t size) {
+  name_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.FunctionSignature.Scalar.name)
+}
+inline std::string* FunctionSignature_Scalar::_internal_add_name() {
+  return name_.Add();
+}
+inline void FunctionSignature_Scalar::add_name(const std::string& value) {
+  name_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.name)
+}
+inline void FunctionSignature_Scalar::add_name(std::string&& value) {
+  name_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.name)
+}
+inline void FunctionSignature_Scalar::add_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  name_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.FunctionSignature.Scalar.name)
+}
+inline void FunctionSignature_Scalar::add_name(const char* value, size_t size) {
+  name_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Scalar.name)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+FunctionSignature_Scalar::name() const {
+  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.name)
+  return name_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+FunctionSignature_Scalar::mutable_name() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Scalar.name)
+  return &name_;
+}
+
+// .substrait.FunctionSignature.Description description = 4;
+inline bool FunctionSignature_Scalar::_internal_has_description() const {
+  return this != internal_default_instance() && description_ != nullptr;
+}
+inline bool FunctionSignature_Scalar::has_description() const {
+  return _internal_has_description();
+}
+inline void FunctionSignature_Scalar::clear_description() {
+  if (GetArenaForAllocation() == nullptr && description_ != nullptr) {
+    delete description_;
+  }
+  description_ = nullptr;
+}
+inline const ::substrait::FunctionSignature_Description& FunctionSignature_Scalar::_internal_description() const {
+  const ::substrait::FunctionSignature_Description* p = description_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::FunctionSignature_Description&>(
+      ::substrait::_FunctionSignature_Description_default_instance_);
+}
+inline const ::substrait::FunctionSignature_Description& FunctionSignature_Scalar::description() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.description)
+  return _internal_description();
+}
+inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_description(
+    ::substrait::FunctionSignature_Description* description) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_);
+  }
+  description_ = description;
+  if (description) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.description)
+}
+inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::release_description() {
+  
+  ::substrait::FunctionSignature_Description* temp = description_;
+  description_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::unsafe_arena_release_description() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.description)
+  
+  ::substrait::FunctionSignature_Description* temp = description_;
+  description_ = nullptr;
+  return temp;
+}
+inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::_internal_mutable_description() {
+  
+  if (description_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArenaForAllocation());
+    description_ = p;
+  }
+  return description_;
+}
+inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::mutable_description() {
+  ::substrait::FunctionSignature_Description* _msg = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.description)
+  return _msg;
+}
+inline void FunctionSignature_Scalar::set_allocated_description(::substrait::FunctionSignature_Description* description) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete description_;
+  }
+  if (description) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Description>::GetOwningArena(description);
+    if (message_arena != submessage_arena) {
+      description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, description, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  description_ = description;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.description)
+}
+
+// bool deterministic = 7;
+inline void FunctionSignature_Scalar::clear_deterministic() {
+  deterministic_ = false;
+}
+inline bool FunctionSignature_Scalar::_internal_deterministic() const {
+  return deterministic_;
+}
+inline bool FunctionSignature_Scalar::deterministic() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.deterministic)
+  return _internal_deterministic();
+}
+inline void FunctionSignature_Scalar::_internal_set_deterministic(bool value) {
+  
+  deterministic_ = value;
+}
+inline void FunctionSignature_Scalar::set_deterministic(bool value) {
+  _internal_set_deterministic(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.deterministic)
+}
+
+// bool session_dependent = 8;
+inline void FunctionSignature_Scalar::clear_session_dependent() {
+  session_dependent_ = false;
+}
+inline bool FunctionSignature_Scalar::_internal_session_dependent() const {
+  return session_dependent_;
+}
+inline bool FunctionSignature_Scalar::session_dependent() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.session_dependent)
+  return _internal_session_dependent();
+}
+inline void FunctionSignature_Scalar::_internal_set_session_dependent(bool value) {
+  
+  session_dependent_ = value;
+}
+inline void FunctionSignature_Scalar::set_session_dependent(bool value) {
+  _internal_set_session_dependent(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.session_dependent)
+}
+
+// .substrait.DerivationExpression output_type = 9;
+inline bool FunctionSignature_Scalar::_internal_has_output_type() const {
+  return this != internal_default_instance() && output_type_ != nullptr;
+}
+inline bool FunctionSignature_Scalar::has_output_type() const {
+  return _internal_has_output_type();
+}
+inline const ::substrait::DerivationExpression& FunctionSignature_Scalar::_internal_output_type() const {
+  const ::substrait::DerivationExpression* p = output_type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& FunctionSignature_Scalar::output_type() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.output_type)
+  return _internal_output_type();
+}
+inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_output_type(
+    ::substrait::DerivationExpression* output_type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  output_type_ = output_type;
+  if (output_type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.output_type)
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Scalar::release_output_type() {
+  
+  ::substrait::DerivationExpression* temp = output_type_;
+  output_type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Scalar::unsafe_arena_release_output_type() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.output_type)
+  
+  ::substrait::DerivationExpression* temp = output_type_;
+  output_type_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Scalar::_internal_mutable_output_type() {
+  
+  if (output_type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    output_type_ = p;
+  }
+  return output_type_;
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Scalar::mutable_output_type() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_output_type();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.output_type)
+  return _msg;
+}
+inline void FunctionSignature_Scalar::set_allocated_output_type(::substrait::DerivationExpression* output_type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  if (output_type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type));
+    if (message_arena != submessage_arena) {
+      output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, output_type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  output_type_ = output_type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.output_type)
+}
+
+// .substrait.FunctionSignature.FinalArgVariadic variadic = 10;
+inline bool FunctionSignature_Scalar::_internal_has_variadic() const {
+  return final_variable_behavior_case() == kVariadic;
+}
+inline bool FunctionSignature_Scalar::has_variadic() const {
+  return _internal_has_variadic();
+}
+inline void FunctionSignature_Scalar::set_has_variadic() {
+  _oneof_case_[0] = kVariadic;
+}
+inline void FunctionSignature_Scalar::clear_variadic() {
+  if (_internal_has_variadic()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete final_variable_behavior_.variadic_;
+    }
+    clear_has_final_variable_behavior();
+  }
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::release_variadic() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.variadic)
+  if (_internal_has_variadic()) {
+    clear_has_final_variable_behavior();
+      ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    final_variable_behavior_.variadic_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::_internal_variadic() const {
+  return _internal_has_variadic()
+      ? *final_variable_behavior_.variadic_
+      : reinterpret_cast< ::substrait::FunctionSignature_FinalArgVariadic&>(::substrait::_FunctionSignature_FinalArgVariadic_default_instance_);
+}
+inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::variadic() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.variadic)
+  return _internal_variadic();
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::unsafe_arena_release_variadic() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Scalar.variadic)
+  if (_internal_has_variadic()) {
+    clear_has_final_variable_behavior();
+    ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_;
+    final_variable_behavior_.variadic_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) {
+  clear_final_variable_behavior();
+  if (variadic) {
+    set_has_variadic();
+    final_variable_behavior_.variadic_ = variadic;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.variadic)
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::_internal_mutable_variadic() {
+  if (!_internal_has_variadic()) {
+    clear_final_variable_behavior();
+    set_has_variadic();
+    final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArenaForAllocation());
+  }
+  return final_variable_behavior_.variadic_;
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::mutable_variadic() {
+  ::substrait::FunctionSignature_FinalArgVariadic* _msg = _internal_mutable_variadic();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.variadic)
+  return _msg;
+}
+
+// .substrait.FunctionSignature.FinalArgNormal normal = 11;
+inline bool FunctionSignature_Scalar::_internal_has_normal() const {
+  return final_variable_behavior_case() == kNormal;
+}
+inline bool FunctionSignature_Scalar::has_normal() const {
+  return _internal_has_normal();
+}
+inline void FunctionSignature_Scalar::set_has_normal() {
+  _oneof_case_[0] = kNormal;
+}
+inline void FunctionSignature_Scalar::clear_normal() {
+  if (_internal_has_normal()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete final_variable_behavior_.normal_;
+    }
+    clear_has_final_variable_behavior();
+  }
+}
+inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::release_normal() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.normal)
+  if (_internal_has_normal()) {
+    clear_has_final_variable_behavior();
+      ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    final_variable_behavior_.normal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::_internal_normal() const {
+  return _internal_has_normal()
+      ? *final_variable_behavior_.normal_
+      : reinterpret_cast< ::substrait::FunctionSignature_FinalArgNormal&>(::substrait::_FunctionSignature_FinalArgNormal_default_instance_);
+}
+inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::normal() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.normal)
+  return _internal_normal();
+}
+inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::unsafe_arena_release_normal() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Scalar.normal)
+  if (_internal_has_normal()) {
+    clear_has_final_variable_behavior();
+    ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_;
+    final_variable_behavior_.normal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) {
+  clear_final_variable_behavior();
+  if (normal) {
+    set_has_normal();
+    final_variable_behavior_.normal_ = normal;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.normal)
+}
+inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::_internal_mutable_normal() {
+  if (!_internal_has_normal()) {
+    clear_final_variable_behavior();
+    set_has_normal();
+    final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArenaForAllocation());
+  }
+  return final_variable_behavior_.normal_;
+}
+inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::mutable_normal() {
+  ::substrait::FunctionSignature_FinalArgNormal* _msg = _internal_mutable_normal();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.normal)
+  return _msg;
+}
+
+// repeated .substrait.FunctionSignature.Implementation implementations = 12;
+inline int FunctionSignature_Scalar::_internal_implementations_size() const {
+  return implementations_.size();
+}
+inline int FunctionSignature_Scalar::implementations_size() const {
+  return _internal_implementations_size();
+}
+inline void FunctionSignature_Scalar::clear_implementations() {
+  implementations_.Clear();
+}
+inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::mutable_implementations(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.implementations)
+  return implementations_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >*
+FunctionSignature_Scalar::mutable_implementations() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Scalar.implementations)
+  return &implementations_;
+}
+inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Scalar::_internal_implementations(int index) const {
+  return implementations_.Get(index);
+}
+inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Scalar::implementations(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.implementations)
+  return _internal_implementations(index);
+}
+inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::_internal_add_implementations() {
+  return implementations_.Add();
+}
+inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::add_implementations() {
+  ::substrait::FunctionSignature_Implementation* _add = _internal_add_implementations();
+  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.implementations)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >&
+FunctionSignature_Scalar::implementations() const {
+  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.implementations)
+  return implementations_;
+}
+
+inline bool FunctionSignature_Scalar::has_final_variable_behavior() const {
+  return final_variable_behavior_case() != FINAL_VARIABLE_BEHAVIOR_NOT_SET;
+}
+inline void FunctionSignature_Scalar::clear_has_final_variable_behavior() {
+  _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET;
+}
+inline FunctionSignature_Scalar::FinalVariableBehaviorCase FunctionSignature_Scalar::final_variable_behavior_case() const {
+  return FunctionSignature_Scalar::FinalVariableBehaviorCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// FunctionSignature_Aggregate
+
+// repeated .substrait.FunctionSignature.Argument arguments = 2;
+inline int FunctionSignature_Aggregate::_internal_arguments_size() const {
+  return arguments_.size();
+}
+inline int FunctionSignature_Aggregate::arguments_size() const {
+  return _internal_arguments_size();
+}
+inline void FunctionSignature_Aggregate::clear_arguments() {
+  arguments_.Clear();
+}
+inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::mutable_arguments(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.arguments)
+  return arguments_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >*
+FunctionSignature_Aggregate::mutable_arguments() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Aggregate.arguments)
+  return &arguments_;
+}
+inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Aggregate::_internal_arguments(int index) const {
+  return arguments_.Get(index);
+}
+inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Aggregate::arguments(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.arguments)
+  return _internal_arguments(index);
+}
+inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::_internal_add_arguments() {
+  return arguments_.Add();
+}
+inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::add_arguments() {
+  ::substrait::FunctionSignature_Argument* _add = _internal_add_arguments();
+  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Aggregate.arguments)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >&
+FunctionSignature_Aggregate::arguments() const {
+  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Aggregate.arguments)
+  return arguments_;
+}
+
+// string name = 3;
+inline void FunctionSignature_Aggregate::clear_name() {
+  name_.ClearToEmpty();
+}
+inline const std::string& FunctionSignature_Aggregate::name() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FunctionSignature_Aggregate::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.name)
+}
+inline std::string* FunctionSignature_Aggregate::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.name)
+  return _s;
+}
+inline const std::string& FunctionSignature_Aggregate::_internal_name() const {
+  return name_.Get();
+}
+inline void FunctionSignature_Aggregate::_internal_set_name(const std::string& value) {
+  
+  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* FunctionSignature_Aggregate::_internal_mutable_name() {
+  
+  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* FunctionSignature_Aggregate::release_name() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.name)
+  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void FunctionSignature_Aggregate::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.name)
+}
+
+// .substrait.FunctionSignature.Description description = 4;
+inline bool FunctionSignature_Aggregate::_internal_has_description() const {
+  return this != internal_default_instance() && description_ != nullptr;
+}
+inline bool FunctionSignature_Aggregate::has_description() const {
+  return _internal_has_description();
+}
+inline void FunctionSignature_Aggregate::clear_description() {
+  if (GetArenaForAllocation() == nullptr && description_ != nullptr) {
+    delete description_;
+  }
+  description_ = nullptr;
+}
+inline const ::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::_internal_description() const {
+  const ::substrait::FunctionSignature_Description* p = description_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::FunctionSignature_Description&>(
+      ::substrait::_FunctionSignature_Description_default_instance_);
+}
+inline const ::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::description() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.description)
+  return _internal_description();
+}
+inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_description(
+    ::substrait::FunctionSignature_Description* description) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_);
+  }
+  description_ = description;
+  if (description) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.description)
+}
+inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::release_description() {
+  
+  ::substrait::FunctionSignature_Description* temp = description_;
+  description_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::unsafe_arena_release_description() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.description)
+  
+  ::substrait::FunctionSignature_Description* temp = description_;
+  description_ = nullptr;
+  return temp;
+}
+inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::_internal_mutable_description() {
+  
+  if (description_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArenaForAllocation());
+    description_ = p;
+  }
+  return description_;
+}
+inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::mutable_description() {
+  ::substrait::FunctionSignature_Description* _msg = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.description)
+  return _msg;
+}
+inline void FunctionSignature_Aggregate::set_allocated_description(::substrait::FunctionSignature_Description* description) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete description_;
+  }
+  if (description) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Description>::GetOwningArena(description);
+    if (message_arena != submessage_arena) {
+      description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, description, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  description_ = description;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.description)
+}
+
+// bool deterministic = 7;
+inline void FunctionSignature_Aggregate::clear_deterministic() {
+  deterministic_ = false;
+}
+inline bool FunctionSignature_Aggregate::_internal_deterministic() const {
+  return deterministic_;
+}
+inline bool FunctionSignature_Aggregate::deterministic() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.deterministic)
+  return _internal_deterministic();
+}
+inline void FunctionSignature_Aggregate::_internal_set_deterministic(bool value) {
+  
+  deterministic_ = value;
+}
+inline void FunctionSignature_Aggregate::set_deterministic(bool value) {
+  _internal_set_deterministic(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.deterministic)
+}
+
+// bool session_dependent = 8;
+inline void FunctionSignature_Aggregate::clear_session_dependent() {
+  session_dependent_ = false;
+}
+inline bool FunctionSignature_Aggregate::_internal_session_dependent() const {
+  return session_dependent_;
+}
+inline bool FunctionSignature_Aggregate::session_dependent() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.session_dependent)
+  return _internal_session_dependent();
+}
+inline void FunctionSignature_Aggregate::_internal_set_session_dependent(bool value) {
+  
+  session_dependent_ = value;
+}
+inline void FunctionSignature_Aggregate::set_session_dependent(bool value) {
+  _internal_set_session_dependent(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.session_dependent)
+}
+
+// .substrait.DerivationExpression output_type = 9;
+inline bool FunctionSignature_Aggregate::_internal_has_output_type() const {
+  return this != internal_default_instance() && output_type_ != nullptr;
+}
+inline bool FunctionSignature_Aggregate::has_output_type() const {
+  return _internal_has_output_type();
+}
+inline const ::substrait::DerivationExpression& FunctionSignature_Aggregate::_internal_output_type() const {
+  const ::substrait::DerivationExpression* p = output_type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& FunctionSignature_Aggregate::output_type() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.output_type)
+  return _internal_output_type();
+}
+inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_output_type(
+    ::substrait::DerivationExpression* output_type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  output_type_ = output_type;
+  if (output_type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.output_type)
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::release_output_type() {
+  
+  ::substrait::DerivationExpression* temp = output_type_;
+  output_type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::unsafe_arena_release_output_type() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.output_type)
+  
+  ::substrait::DerivationExpression* temp = output_type_;
+  output_type_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::_internal_mutable_output_type() {
+  
+  if (output_type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    output_type_ = p;
+  }
+  return output_type_;
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::mutable_output_type() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_output_type();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.output_type)
+  return _msg;
+}
+inline void FunctionSignature_Aggregate::set_allocated_output_type(::substrait::DerivationExpression* output_type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  if (output_type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type));
+    if (message_arena != submessage_arena) {
+      output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, output_type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  output_type_ = output_type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.output_type)
+}
+
+// .substrait.FunctionSignature.FinalArgVariadic variadic = 10;
+inline bool FunctionSignature_Aggregate::_internal_has_variadic() const {
+  return final_variable_behavior_case() == kVariadic;
+}
+inline bool FunctionSignature_Aggregate::has_variadic() const {
+  return _internal_has_variadic();
+}
+inline void FunctionSignature_Aggregate::set_has_variadic() {
+  _oneof_case_[0] = kVariadic;
+}
+inline void FunctionSignature_Aggregate::clear_variadic() {
+  if (_internal_has_variadic()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete final_variable_behavior_.variadic_;
+    }
+    clear_has_final_variable_behavior();
+  }
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::release_variadic() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.variadic)
+  if (_internal_has_variadic()) {
+    clear_has_final_variable_behavior();
+      ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    final_variable_behavior_.variadic_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::_internal_variadic() const {
+  return _internal_has_variadic()
+      ? *final_variable_behavior_.variadic_
+      : reinterpret_cast< ::substrait::FunctionSignature_FinalArgVariadic&>(::substrait::_FunctionSignature_FinalArgVariadic_default_instance_);
+}
+inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::variadic() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.variadic)
+  return _internal_variadic();
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::unsafe_arena_release_variadic() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Aggregate.variadic)
+  if (_internal_has_variadic()) {
+    clear_has_final_variable_behavior();
+    ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_;
+    final_variable_behavior_.variadic_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) {
+  clear_final_variable_behavior();
+  if (variadic) {
+    set_has_variadic();
+    final_variable_behavior_.variadic_ = variadic;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.variadic)
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::_internal_mutable_variadic() {
+  if (!_internal_has_variadic()) {
+    clear_final_variable_behavior();
+    set_has_variadic();
+    final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArenaForAllocation());
+  }
+  return final_variable_behavior_.variadic_;
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::mutable_variadic() {
+  ::substrait::FunctionSignature_FinalArgVariadic* _msg = _internal_mutable_variadic();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.variadic)
+  return _msg;
+}
+
+// .substrait.FunctionSignature.FinalArgNormal normal = 11;
+inline bool FunctionSignature_Aggregate::_internal_has_normal() const {
+  return final_variable_behavior_case() == kNormal;
+}
+inline bool FunctionSignature_Aggregate::has_normal() const {
+  return _internal_has_normal();
+}
+inline void FunctionSignature_Aggregate::set_has_normal() {
+  _oneof_case_[0] = kNormal;
+}
+inline void FunctionSignature_Aggregate::clear_normal() {
+  if (_internal_has_normal()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete final_variable_behavior_.normal_;
+    }
+    clear_has_final_variable_behavior();
+  }
+}
+inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::release_normal() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.normal)
+  if (_internal_has_normal()) {
+    clear_has_final_variable_behavior();
+      ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    final_variable_behavior_.normal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::_internal_normal() const {
+  return _internal_has_normal()
+      ? *final_variable_behavior_.normal_
+      : reinterpret_cast< ::substrait::FunctionSignature_FinalArgNormal&>(::substrait::_FunctionSignature_FinalArgNormal_default_instance_);
+}
+inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::normal() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.normal)
+  return _internal_normal();
+}
+inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::unsafe_arena_release_normal() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Aggregate.normal)
+  if (_internal_has_normal()) {
+    clear_has_final_variable_behavior();
+    ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_;
+    final_variable_behavior_.normal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) {
+  clear_final_variable_behavior();
+  if (normal) {
+    set_has_normal();
+    final_variable_behavior_.normal_ = normal;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.normal)
+}
+inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::_internal_mutable_normal() {
+  if (!_internal_has_normal()) {
+    clear_final_variable_behavior();
+    set_has_normal();
+    final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArenaForAllocation());
+  }
+  return final_variable_behavior_.normal_;
+}
+inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::mutable_normal() {
+  ::substrait::FunctionSignature_FinalArgNormal* _msg = _internal_mutable_normal();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.normal)
+  return _msg;
+}
+
+// bool ordered = 14;
+inline void FunctionSignature_Aggregate::clear_ordered() {
+  ordered_ = false;
+}
+inline bool FunctionSignature_Aggregate::_internal_ordered() const {
+  return ordered_;
+}
+inline bool FunctionSignature_Aggregate::ordered() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.ordered)
+  return _internal_ordered();
+}
+inline void FunctionSignature_Aggregate::_internal_set_ordered(bool value) {
+  
+  ordered_ = value;
+}
+inline void FunctionSignature_Aggregate::set_ordered(bool value) {
+  _internal_set_ordered(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.ordered)
+}
+
+// uint64 max_set = 12;
+inline void FunctionSignature_Aggregate::clear_max_set() {
+  max_set_ = uint64_t{0u};
+}
+inline uint64_t FunctionSignature_Aggregate::_internal_max_set() const {
+  return max_set_;
+}
+inline uint64_t FunctionSignature_Aggregate::max_set() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.max_set)
+  return _internal_max_set();
+}
+inline void FunctionSignature_Aggregate::_internal_set_max_set(uint64_t value) {
+  
+  max_set_ = value;
+}
+inline void FunctionSignature_Aggregate::set_max_set(uint64_t value) {
+  _internal_set_max_set(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.max_set)
+}
+
+// .substrait.Type intermediate_type = 13;
+inline bool FunctionSignature_Aggregate::_internal_has_intermediate_type() const {
+  return this != internal_default_instance() && intermediate_type_ != nullptr;
+}
+inline bool FunctionSignature_Aggregate::has_intermediate_type() const {
+  return _internal_has_intermediate_type();
+}
+inline const ::substrait::Type& FunctionSignature_Aggregate::_internal_intermediate_type() const {
+  const ::substrait::Type* p = intermediate_type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Type&>(
+      ::substrait::_Type_default_instance_);
+}
+inline const ::substrait::Type& FunctionSignature_Aggregate::intermediate_type() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.intermediate_type)
+  return _internal_intermediate_type();
+}
+inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_intermediate_type(
+    ::substrait::Type* intermediate_type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_);
+  }
+  intermediate_type_ = intermediate_type;
+  if (intermediate_type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.intermediate_type)
+}
+inline ::substrait::Type* FunctionSignature_Aggregate::release_intermediate_type() {
+  
+  ::substrait::Type* temp = intermediate_type_;
+  intermediate_type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Type* FunctionSignature_Aggregate::unsafe_arena_release_intermediate_type() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.intermediate_type)
+  
+  ::substrait::Type* temp = intermediate_type_;
+  intermediate_type_ = nullptr;
+  return temp;
+}
+inline ::substrait::Type* FunctionSignature_Aggregate::_internal_mutable_intermediate_type() {
+  
+  if (intermediate_type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation());
+    intermediate_type_ = p;
+  }
+  return intermediate_type_;
+}
+inline ::substrait::Type* FunctionSignature_Aggregate::mutable_intermediate_type() {
+  ::substrait::Type* _msg = _internal_mutable_intermediate_type();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.intermediate_type)
+  return _msg;
+}
+inline void FunctionSignature_Aggregate::set_allocated_intermediate_type(::substrait::Type* intermediate_type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_);
+  }
+  if (intermediate_type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type));
+    if (message_arena != submessage_arena) {
+      intermediate_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, intermediate_type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  intermediate_type_ = intermediate_type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.intermediate_type)
+}
+
+// repeated .substrait.FunctionSignature.Implementation implementations = 15;
+inline int FunctionSignature_Aggregate::_internal_implementations_size() const {
+  return implementations_.size();
+}
+inline int FunctionSignature_Aggregate::implementations_size() const {
+  return _internal_implementations_size();
+}
+inline void FunctionSignature_Aggregate::clear_implementations() {
+  implementations_.Clear();
+}
+inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::mutable_implementations(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.implementations)
+  return implementations_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >*
+FunctionSignature_Aggregate::mutable_implementations() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Aggregate.implementations)
+  return &implementations_;
+}
+inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Aggregate::_internal_implementations(int index) const {
+  return implementations_.Get(index);
+}
+inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Aggregate::implementations(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.implementations)
+  return _internal_implementations(index);
+}
+inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::_internal_add_implementations() {
+  return implementations_.Add();
+}
+inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::add_implementations() {
+  ::substrait::FunctionSignature_Implementation* _add = _internal_add_implementations();
+  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Aggregate.implementations)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >&
+FunctionSignature_Aggregate::implementations() const {
+  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Aggregate.implementations)
+  return implementations_;
+}
+
+inline bool FunctionSignature_Aggregate::has_final_variable_behavior() const {
+  return final_variable_behavior_case() != FINAL_VARIABLE_BEHAVIOR_NOT_SET;
+}
+inline void FunctionSignature_Aggregate::clear_has_final_variable_behavior() {
+  _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET;
+}
+inline FunctionSignature_Aggregate::FinalVariableBehaviorCase FunctionSignature_Aggregate::final_variable_behavior_case() const {
+  return FunctionSignature_Aggregate::FinalVariableBehaviorCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// FunctionSignature_Window
+
+// repeated .substrait.FunctionSignature.Argument arguments = 2;
+inline int FunctionSignature_Window::_internal_arguments_size() const {
+  return arguments_.size();
+}
+inline int FunctionSignature_Window::arguments_size() const {
+  return _internal_arguments_size();
+}
+inline void FunctionSignature_Window::clear_arguments() {
+  arguments_.Clear();
+}
+inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::mutable_arguments(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.arguments)
+  return arguments_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >*
+FunctionSignature_Window::mutable_arguments() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Window.arguments)
+  return &arguments_;
+}
+inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Window::_internal_arguments(int index) const {
+  return arguments_.Get(index);
+}
+inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Window::arguments(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.arguments)
+  return _internal_arguments(index);
+}
+inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::_internal_add_arguments() {
+  return arguments_.Add();
+}
+inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::add_arguments() {
+  ::substrait::FunctionSignature_Argument* _add = _internal_add_arguments();
+  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.arguments)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >&
+FunctionSignature_Window::arguments() const {
+  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.arguments)
+  return arguments_;
+}
+
+// repeated string name = 3;
+inline int FunctionSignature_Window::_internal_name_size() const {
+  return name_.size();
+}
+inline int FunctionSignature_Window::name_size() const {
+  return _internal_name_size();
+}
+inline void FunctionSignature_Window::clear_name() {
+  name_.Clear();
+}
+inline std::string* FunctionSignature_Window::add_name() {
+  std::string* _s = _internal_add_name();
+  // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Window.name)
+  return _s;
+}
+inline const std::string& FunctionSignature_Window::_internal_name(int index) const {
+  return name_.Get(index);
+}
+inline const std::string& FunctionSignature_Window::name(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.name)
+  return _internal_name(index);
+}
+inline std::string* FunctionSignature_Window::mutable_name(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.name)
+  return name_.Mutable(index);
+}
+inline void FunctionSignature_Window::set_name(int index, const std::string& value) {
+  name_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.name)
+}
+inline void FunctionSignature_Window::set_name(int index, std::string&& value) {
+  name_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.name)
+}
+inline void FunctionSignature_Window::set_name(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  name_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.FunctionSignature.Window.name)
+}
+inline void FunctionSignature_Window::set_name(int index, const char* value, size_t size) {
+  name_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.FunctionSignature.Window.name)
+}
+inline std::string* FunctionSignature_Window::_internal_add_name() {
+  return name_.Add();
+}
+inline void FunctionSignature_Window::add_name(const std::string& value) {
+  name_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.name)
+}
+inline void FunctionSignature_Window::add_name(std::string&& value) {
+  name_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.name)
+}
+inline void FunctionSignature_Window::add_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  name_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.FunctionSignature.Window.name)
+}
+inline void FunctionSignature_Window::add_name(const char* value, size_t size) {
+  name_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Window.name)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+FunctionSignature_Window::name() const {
+  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.name)
+  return name_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+FunctionSignature_Window::mutable_name() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Window.name)
+  return &name_;
+}
+
+// .substrait.FunctionSignature.Description description = 4;
+inline bool FunctionSignature_Window::_internal_has_description() const {
+  return this != internal_default_instance() && description_ != nullptr;
+}
+inline bool FunctionSignature_Window::has_description() const {
+  return _internal_has_description();
+}
+inline void FunctionSignature_Window::clear_description() {
+  if (GetArenaForAllocation() == nullptr && description_ != nullptr) {
+    delete description_;
+  }
+  description_ = nullptr;
+}
+inline const ::substrait::FunctionSignature_Description& FunctionSignature_Window::_internal_description() const {
+  const ::substrait::FunctionSignature_Description* p = description_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::FunctionSignature_Description&>(
+      ::substrait::_FunctionSignature_Description_default_instance_);
+}
+inline const ::substrait::FunctionSignature_Description& FunctionSignature_Window::description() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.description)
+  return _internal_description();
+}
+inline void FunctionSignature_Window::unsafe_arena_set_allocated_description(
+    ::substrait::FunctionSignature_Description* description) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_);
+  }
+  description_ = description;
+  if (description) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.description)
+}
+inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::release_description() {
+  
+  ::substrait::FunctionSignature_Description* temp = description_;
+  description_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::unsafe_arena_release_description() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.description)
+  
+  ::substrait::FunctionSignature_Description* temp = description_;
+  description_ = nullptr;
+  return temp;
+}
+inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::_internal_mutable_description() {
+  
+  if (description_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArenaForAllocation());
+    description_ = p;
+  }
+  return description_;
+}
+inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::mutable_description() {
+  ::substrait::FunctionSignature_Description* _msg = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.description)
+  return _msg;
+}
+inline void FunctionSignature_Window::set_allocated_description(::substrait::FunctionSignature_Description* description) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete description_;
+  }
+  if (description) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Description>::GetOwningArena(description);
+    if (message_arena != submessage_arena) {
+      description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, description, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  description_ = description;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.description)
+}
+
+// bool deterministic = 7;
+inline void FunctionSignature_Window::clear_deterministic() {
+  deterministic_ = false;
+}
+inline bool FunctionSignature_Window::_internal_deterministic() const {
+  return deterministic_;
+}
+inline bool FunctionSignature_Window::deterministic() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.deterministic)
+  return _internal_deterministic();
+}
+inline void FunctionSignature_Window::_internal_set_deterministic(bool value) {
+  
+  deterministic_ = value;
+}
+inline void FunctionSignature_Window::set_deterministic(bool value) {
+  _internal_set_deterministic(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.deterministic)
+}
+
+// bool session_dependent = 8;
+inline void FunctionSignature_Window::clear_session_dependent() {
+  session_dependent_ = false;
+}
+inline bool FunctionSignature_Window::_internal_session_dependent() const {
+  return session_dependent_;
+}
+inline bool FunctionSignature_Window::session_dependent() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.session_dependent)
+  return _internal_session_dependent();
+}
+inline void FunctionSignature_Window::_internal_set_session_dependent(bool value) {
+  
+  session_dependent_ = value;
+}
+inline void FunctionSignature_Window::set_session_dependent(bool value) {
+  _internal_set_session_dependent(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.session_dependent)
+}
+
+// .substrait.DerivationExpression intermediate_type = 9;
+inline bool FunctionSignature_Window::_internal_has_intermediate_type() const {
+  return this != internal_default_instance() && intermediate_type_ != nullptr;
+}
+inline bool FunctionSignature_Window::has_intermediate_type() const {
+  return _internal_has_intermediate_type();
+}
+inline const ::substrait::DerivationExpression& FunctionSignature_Window::_internal_intermediate_type() const {
+  const ::substrait::DerivationExpression* p = intermediate_type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& FunctionSignature_Window::intermediate_type() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.intermediate_type)
+  return _internal_intermediate_type();
+}
+inline void FunctionSignature_Window::unsafe_arena_set_allocated_intermediate_type(
+    ::substrait::DerivationExpression* intermediate_type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_);
+  }
+  intermediate_type_ = intermediate_type;
+  if (intermediate_type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.intermediate_type)
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Window::release_intermediate_type() {
+  
+  ::substrait::DerivationExpression* temp = intermediate_type_;
+  intermediate_type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_intermediate_type() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.intermediate_type)
+  
+  ::substrait::DerivationExpression* temp = intermediate_type_;
+  intermediate_type_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_intermediate_type() {
+  
+  if (intermediate_type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    intermediate_type_ = p;
+  }
+  return intermediate_type_;
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Window::mutable_intermediate_type() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_intermediate_type();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.intermediate_type)
+  return _msg;
+}
+inline void FunctionSignature_Window::set_allocated_intermediate_type(::substrait::DerivationExpression* intermediate_type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_);
+  }
+  if (intermediate_type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type));
+    if (message_arena != submessage_arena) {
+      intermediate_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, intermediate_type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  intermediate_type_ = intermediate_type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.intermediate_type)
+}
+
+// .substrait.DerivationExpression output_type = 10;
+inline bool FunctionSignature_Window::_internal_has_output_type() const {
+  return this != internal_default_instance() && output_type_ != nullptr;
+}
+inline bool FunctionSignature_Window::has_output_type() const {
+  return _internal_has_output_type();
+}
+inline const ::substrait::DerivationExpression& FunctionSignature_Window::_internal_output_type() const {
+  const ::substrait::DerivationExpression* p = output_type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& FunctionSignature_Window::output_type() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.output_type)
+  return _internal_output_type();
+}
+inline void FunctionSignature_Window::unsafe_arena_set_allocated_output_type(
+    ::substrait::DerivationExpression* output_type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  output_type_ = output_type;
+  if (output_type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.output_type)
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Window::release_output_type() {
+  
+  ::substrait::DerivationExpression* temp = output_type_;
+  output_type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_output_type() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.output_type)
+  
+  ::substrait::DerivationExpression* temp = output_type_;
+  output_type_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_output_type() {
+  
+  if (output_type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    output_type_ = p;
+  }
+  return output_type_;
+}
+inline ::substrait::DerivationExpression* FunctionSignature_Window::mutable_output_type() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_output_type();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.output_type)
+  return _msg;
+}
+inline void FunctionSignature_Window::set_allocated_output_type(::substrait::DerivationExpression* output_type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_);
+  }
+  if (output_type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type));
+    if (message_arena != submessage_arena) {
+      output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, output_type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  output_type_ = output_type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.output_type)
+}
+
+// .substrait.FunctionSignature.FinalArgVariadic variadic = 16;
+inline bool FunctionSignature_Window::_internal_has_variadic() const {
+  return final_variable_behavior_case() == kVariadic;
+}
+inline bool FunctionSignature_Window::has_variadic() const {
+  return _internal_has_variadic();
+}
+inline void FunctionSignature_Window::set_has_variadic() {
+  _oneof_case_[0] = kVariadic;
+}
+inline void FunctionSignature_Window::clear_variadic() {
+  if (_internal_has_variadic()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete final_variable_behavior_.variadic_;
+    }
+    clear_has_final_variable_behavior();
+  }
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::release_variadic() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.variadic)
+  if (_internal_has_variadic()) {
+    clear_has_final_variable_behavior();
+      ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    final_variable_behavior_.variadic_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::_internal_variadic() const {
+  return _internal_has_variadic()
+      ? *final_variable_behavior_.variadic_
+      : reinterpret_cast< ::substrait::FunctionSignature_FinalArgVariadic&>(::substrait::_FunctionSignature_FinalArgVariadic_default_instance_);
+}
+inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::variadic() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.variadic)
+  return _internal_variadic();
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::unsafe_arena_release_variadic() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Window.variadic)
+  if (_internal_has_variadic()) {
+    clear_has_final_variable_behavior();
+    ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_;
+    final_variable_behavior_.variadic_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void FunctionSignature_Window::unsafe_arena_set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) {
+  clear_final_variable_behavior();
+  if (variadic) {
+    set_has_variadic();
+    final_variable_behavior_.variadic_ = variadic;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.variadic)
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::_internal_mutable_variadic() {
+  if (!_internal_has_variadic()) {
+    clear_final_variable_behavior();
+    set_has_variadic();
+    final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArenaForAllocation());
+  }
+  return final_variable_behavior_.variadic_;
+}
+inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::mutable_variadic() {
+  ::substrait::FunctionSignature_FinalArgVariadic* _msg = _internal_mutable_variadic();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.variadic)
+  return _msg;
+}
+
+// .substrait.FunctionSignature.FinalArgNormal normal = 17;
+inline bool FunctionSignature_Window::_internal_has_normal() const {
+  return final_variable_behavior_case() == kNormal;
+}
+inline bool FunctionSignature_Window::has_normal() const {
+  return _internal_has_normal();
+}
+inline void FunctionSignature_Window::set_has_normal() {
+  _oneof_case_[0] = kNormal;
+}
+inline void FunctionSignature_Window::clear_normal() {
+  if (_internal_has_normal()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete final_variable_behavior_.normal_;
+    }
+    clear_has_final_variable_behavior();
+  }
+}
+inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::release_normal() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.normal)
+  if (_internal_has_normal()) {
+    clear_has_final_variable_behavior();
+      ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    final_variable_behavior_.normal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::_internal_normal() const {
+  return _internal_has_normal()
+      ? *final_variable_behavior_.normal_
+      : reinterpret_cast< ::substrait::FunctionSignature_FinalArgNormal&>(::substrait::_FunctionSignature_FinalArgNormal_default_instance_);
+}
+inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::normal() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.normal)
+  return _internal_normal();
+}
+inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::unsafe_arena_release_normal() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Window.normal)
+  if (_internal_has_normal()) {
+    clear_has_final_variable_behavior();
+    ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_;
+    final_variable_behavior_.normal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void FunctionSignature_Window::unsafe_arena_set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) {
+  clear_final_variable_behavior();
+  if (normal) {
+    set_has_normal();
+    final_variable_behavior_.normal_ = normal;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.normal)
+}
+inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::_internal_mutable_normal() {
+  if (!_internal_has_normal()) {
+    clear_final_variable_behavior();
+    set_has_normal();
+    final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArenaForAllocation());
+  }
+  return final_variable_behavior_.normal_;
+}
+inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::mutable_normal() {
+  ::substrait::FunctionSignature_FinalArgNormal* _msg = _internal_mutable_normal();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.normal)
+  return _msg;
+}
+
+// bool ordered = 11;
+inline void FunctionSignature_Window::clear_ordered() {
+  ordered_ = false;
+}
+inline bool FunctionSignature_Window::_internal_ordered() const {
+  return ordered_;
+}
+inline bool FunctionSignature_Window::ordered() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.ordered)
+  return _internal_ordered();
+}
+inline void FunctionSignature_Window::_internal_set_ordered(bool value) {
+  
+  ordered_ = value;
+}
+inline void FunctionSignature_Window::set_ordered(bool value) {
+  _internal_set_ordered(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.ordered)
+}
+
+// uint64 max_set = 12;
+inline void FunctionSignature_Window::clear_max_set() {
+  max_set_ = uint64_t{0u};
+}
+inline uint64_t FunctionSignature_Window::_internal_max_set() const {
+  return max_set_;
+}
+inline uint64_t FunctionSignature_Window::max_set() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.max_set)
+  return _internal_max_set();
+}
+inline void FunctionSignature_Window::_internal_set_max_set(uint64_t value) {
+  
+  max_set_ = value;
+}
+inline void FunctionSignature_Window::set_max_set(uint64_t value) {
+  _internal_set_max_set(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.max_set)
+}
+
+// .substrait.FunctionSignature.Window.WindowType window_type = 14;
+inline void FunctionSignature_Window::clear_window_type() {
+  window_type_ = 0;
+}
+inline ::substrait::FunctionSignature_Window_WindowType FunctionSignature_Window::_internal_window_type() const {
+  return static_cast< ::substrait::FunctionSignature_Window_WindowType >(window_type_);
+}
+inline ::substrait::FunctionSignature_Window_WindowType FunctionSignature_Window::window_type() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.window_type)
+  return _internal_window_type();
+}
+inline void FunctionSignature_Window::_internal_set_window_type(::substrait::FunctionSignature_Window_WindowType value) {
+  
+  window_type_ = value;
+}
+inline void FunctionSignature_Window::set_window_type(::substrait::FunctionSignature_Window_WindowType value) {
+  _internal_set_window_type(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.window_type)
+}
+
+// repeated .substrait.FunctionSignature.Implementation implementations = 15;
+inline int FunctionSignature_Window::_internal_implementations_size() const {
+  return implementations_.size();
+}
+inline int FunctionSignature_Window::implementations_size() const {
+  return _internal_implementations_size();
+}
+inline void FunctionSignature_Window::clear_implementations() {
+  implementations_.Clear();
+}
+inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::mutable_implementations(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.implementations)
+  return implementations_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >*
+FunctionSignature_Window::mutable_implementations() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Window.implementations)
+  return &implementations_;
+}
+inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Window::_internal_implementations(int index) const {
+  return implementations_.Get(index);
+}
+inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Window::implementations(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.implementations)
+  return _internal_implementations(index);
+}
+inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::_internal_add_implementations() {
+  return implementations_.Add();
+}
+inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::add_implementations() {
+  ::substrait::FunctionSignature_Implementation* _add = _internal_add_implementations();
+  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.implementations)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >&
+FunctionSignature_Window::implementations() const {
+  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.implementations)
+  return implementations_;
+}
+
+inline bool FunctionSignature_Window::has_final_variable_behavior() const {
+  return final_variable_behavior_case() != FINAL_VARIABLE_BEHAVIOR_NOT_SET;
+}
+inline void FunctionSignature_Window::clear_has_final_variable_behavior() {
+  _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET;
+}
+inline FunctionSignature_Window::FinalVariableBehaviorCase FunctionSignature_Window::final_variable_behavior_case() const {
+  return FunctionSignature_Window::FinalVariableBehaviorCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// FunctionSignature_Description
+
+// string language = 1;
+inline void FunctionSignature_Description::clear_language() {
+  language_.ClearToEmpty();
+}
+inline const std::string& FunctionSignature_Description::language() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Description.language)
+  return _internal_language();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FunctionSignature_Description::set_language(ArgT0&& arg0, ArgT... args) {
+ 
+ language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Description.language)
+}
+inline std::string* FunctionSignature_Description::mutable_language() {
+  std::string* _s = _internal_mutable_language();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Description.language)
+  return _s;
+}
+inline const std::string& FunctionSignature_Description::_internal_language() const {
+  return language_.Get();
+}
+inline void FunctionSignature_Description::_internal_set_language(const std::string& value) {
+  
+  language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* FunctionSignature_Description::_internal_mutable_language() {
+  
+  return language_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* FunctionSignature_Description::release_language() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Description.language)
+  return language_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void FunctionSignature_Description::set_allocated_language(std::string* language) {
+  if (language != nullptr) {
+    
+  } else {
+    
+  }
+  language_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), language,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (language_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    language_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Description.language)
+}
+
+// string body = 2;
+inline void FunctionSignature_Description::clear_body() {
+  body_.ClearToEmpty();
+}
+inline const std::string& FunctionSignature_Description::body() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Description.body)
+  return _internal_body();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FunctionSignature_Description::set_body(ArgT0&& arg0, ArgT... args) {
+ 
+ body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Description.body)
+}
+inline std::string* FunctionSignature_Description::mutable_body() {
+  std::string* _s = _internal_mutable_body();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Description.body)
+  return _s;
+}
+inline const std::string& FunctionSignature_Description::_internal_body() const {
+  return body_.Get();
+}
+inline void FunctionSignature_Description::_internal_set_body(const std::string& value) {
+  
+  body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* FunctionSignature_Description::_internal_mutable_body() {
+  
+  return body_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* FunctionSignature_Description::release_body() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Description.body)
+  return body_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void FunctionSignature_Description::set_allocated_body(std::string* body) {
+  if (body != nullptr) {
+    
+  } else {
+    
+  }
+  body_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), body,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (body_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Description.body)
+}
+
+// -------------------------------------------------------------------
+
+// FunctionSignature_Implementation
+
+// .substrait.FunctionSignature.Implementation.Type type = 1;
+inline void FunctionSignature_Implementation::clear_type() {
+  type_ = 0;
+}
+inline ::substrait::FunctionSignature_Implementation_Type FunctionSignature_Implementation::_internal_type() const {
+  return static_cast< ::substrait::FunctionSignature_Implementation_Type >(type_);
+}
+inline ::substrait::FunctionSignature_Implementation_Type FunctionSignature_Implementation::type() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Implementation.type)
+  return _internal_type();
+}
+inline void FunctionSignature_Implementation::_internal_set_type(::substrait::FunctionSignature_Implementation_Type value) {
+  
+  type_ = value;
+}
+inline void FunctionSignature_Implementation::set_type(::substrait::FunctionSignature_Implementation_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Implementation.type)
+}
+
+// string uri = 2;
+inline void FunctionSignature_Implementation::clear_uri() {
+  uri_.ClearToEmpty();
+}
+inline const std::string& FunctionSignature_Implementation::uri() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Implementation.uri)
+  return _internal_uri();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FunctionSignature_Implementation::set_uri(ArgT0&& arg0, ArgT... args) {
+ 
+ uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Implementation.uri)
+}
+inline std::string* FunctionSignature_Implementation::mutable_uri() {
+  std::string* _s = _internal_mutable_uri();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Implementation.uri)
+  return _s;
+}
+inline const std::string& FunctionSignature_Implementation::_internal_uri() const {
+  return uri_.Get();
+}
+inline void FunctionSignature_Implementation::_internal_set_uri(const std::string& value) {
+  
+  uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* FunctionSignature_Implementation::_internal_mutable_uri() {
+  
+  return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* FunctionSignature_Implementation::release_uri() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Implementation.uri)
+  return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void FunctionSignature_Implementation::set_allocated_uri(std::string* uri) {
+  if (uri != nullptr) {
+    
+  } else {
+    
+  }
+  uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (uri_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Implementation.uri)
+}
+
+// -------------------------------------------------------------------
+
+// FunctionSignature_Argument_ValueArgument
+
+// .substrait.ParameterizedType type = 1;
+inline bool FunctionSignature_Argument_ValueArgument::_internal_has_type() const {
+  return this != internal_default_instance() && type_ != nullptr;
+}
+inline bool FunctionSignature_Argument_ValueArgument::has_type() const {
+  return _internal_has_type();
+}
+inline const ::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::_internal_type() const {
+  const ::substrait::ParameterizedType* p = type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType&>(
+      ::substrait::_ParameterizedType_default_instance_);
+}
+inline const ::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::type() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.ValueArgument.type)
+  return _internal_type();
+}
+inline void FunctionSignature_Argument_ValueArgument::unsafe_arena_set_allocated_type(
+    ::substrait::ParameterizedType* type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
+  }
+  type_ = type;
+  if (type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.ValueArgument.type)
+}
+inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::release_type() {
+  
+  ::substrait::ParameterizedType* temp = type_;
+  type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::unsafe_arena_release_type() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.ValueArgument.type)
+  
+  ::substrait::ParameterizedType* temp = type_;
+  type_ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::_internal_mutable_type() {
+  
+  if (type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation());
+    type_ = p;
+  }
+  return type_;
+}
+inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::mutable_type() {
+  ::substrait::ParameterizedType* _msg = _internal_mutable_type();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.ValueArgument.type)
+  return _msg;
+}
+inline void FunctionSignature_Argument_ValueArgument::set_allocated_type(::substrait::ParameterizedType* type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
+  }
+  if (type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type));
+    if (message_arena != submessage_arena) {
+      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  type_ = type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.ValueArgument.type)
+}
+
+// bool constant = 2;
+inline void FunctionSignature_Argument_ValueArgument::clear_constant() {
+  constant_ = false;
+}
+inline bool FunctionSignature_Argument_ValueArgument::_internal_constant() const {
+  return constant_;
+}
+inline bool FunctionSignature_Argument_ValueArgument::constant() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.ValueArgument.constant)
+  return _internal_constant();
+}
+inline void FunctionSignature_Argument_ValueArgument::_internal_set_constant(bool value) {
+  
+  constant_ = value;
+}
+inline void FunctionSignature_Argument_ValueArgument::set_constant(bool value) {
+  _internal_set_constant(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.ValueArgument.constant)
+}
+
+// -------------------------------------------------------------------
+
+// FunctionSignature_Argument_TypeArgument
+
+// .substrait.ParameterizedType type = 1;
+inline bool FunctionSignature_Argument_TypeArgument::_internal_has_type() const {
+  return this != internal_default_instance() && type_ != nullptr;
+}
+inline bool FunctionSignature_Argument_TypeArgument::has_type() const {
+  return _internal_has_type();
+}
+inline const ::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::_internal_type() const {
+  const ::substrait::ParameterizedType* p = type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType&>(
+      ::substrait::_ParameterizedType_default_instance_);
+}
+inline const ::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::type() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.TypeArgument.type)
+  return _internal_type();
+}
+inline void FunctionSignature_Argument_TypeArgument::unsafe_arena_set_allocated_type(
+    ::substrait::ParameterizedType* type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
+  }
+  type_ = type;
+  if (type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.TypeArgument.type)
+}
+inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::release_type() {
+  
+  ::substrait::ParameterizedType* temp = type_;
+  type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::unsafe_arena_release_type() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.TypeArgument.type)
+  
+  ::substrait::ParameterizedType* temp = type_;
+  type_ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::_internal_mutable_type() {
+  
+  if (type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation());
+    type_ = p;
+  }
+  return type_;
+}
+inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::mutable_type() {
+  ::substrait::ParameterizedType* _msg = _internal_mutable_type();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.TypeArgument.type)
+  return _msg;
+}
+inline void FunctionSignature_Argument_TypeArgument::set_allocated_type(::substrait::ParameterizedType* type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
+  }
+  if (type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type));
+    if (message_arena != submessage_arena) {
+      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  type_ = type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.TypeArgument.type)
+}
+
+// -------------------------------------------------------------------
+
+// FunctionSignature_Argument_EnumArgument
+
+// repeated string options = 1;
+inline int FunctionSignature_Argument_EnumArgument::_internal_options_size() const {
+  return options_.size();
+}
+inline int FunctionSignature_Argument_EnumArgument::options_size() const {
+  return _internal_options_size();
+}
+inline void FunctionSignature_Argument_EnumArgument::clear_options() {
+  options_.Clear();
+}
+inline std::string* FunctionSignature_Argument_EnumArgument::add_options() {
+  std::string* _s = _internal_add_options();
+  // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Argument.EnumArgument.options)
+  return _s;
+}
+inline const std::string& FunctionSignature_Argument_EnumArgument::_internal_options(int index) const {
+  return options_.Get(index);
+}
+inline const std::string& FunctionSignature_Argument_EnumArgument::options(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.EnumArgument.options)
+  return _internal_options(index);
+}
+inline std::string* FunctionSignature_Argument_EnumArgument::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.EnumArgument.options)
+  return options_.Mutable(index);
+}
+inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const std::string& value) {
+  options_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.options)
+}
+inline void FunctionSignature_Argument_EnumArgument::set_options(int index, std::string&& value) {
+  options_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.options)
+}
+inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  options_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.FunctionSignature.Argument.EnumArgument.options)
+}
+inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const char* value, size_t size) {
+  options_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.FunctionSignature.Argument.EnumArgument.options)
+}
+inline std::string* FunctionSignature_Argument_EnumArgument::_internal_add_options() {
+  return options_.Add();
+}
+inline void FunctionSignature_Argument_EnumArgument::add_options(const std::string& value) {
+  options_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Argument.EnumArgument.options)
+}
+inline void FunctionSignature_Argument_EnumArgument::add_options(std::string&& value) {
+  options_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Argument.EnumArgument.options)
+}
+inline void FunctionSignature_Argument_EnumArgument::add_options(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  options_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.FunctionSignature.Argument.EnumArgument.options)
+}
+inline void FunctionSignature_Argument_EnumArgument::add_options(const char* value, size_t size) {
+  options_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Argument.EnumArgument.options)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+FunctionSignature_Argument_EnumArgument::options() const {
+  // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Argument.EnumArgument.options)
+  return options_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+FunctionSignature_Argument_EnumArgument::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Argument.EnumArgument.options)
+  return &options_;
+}
+
+// bool optional = 2;
+inline void FunctionSignature_Argument_EnumArgument::clear_optional() {
+  optional_ = false;
+}
+inline bool FunctionSignature_Argument_EnumArgument::_internal_optional() const {
+  return optional_;
+}
+inline bool FunctionSignature_Argument_EnumArgument::optional() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.EnumArgument.optional)
+  return _internal_optional();
+}
+inline void FunctionSignature_Argument_EnumArgument::_internal_set_optional(bool value) {
+  
+  optional_ = value;
+}
+inline void FunctionSignature_Argument_EnumArgument::set_optional(bool value) {
+  _internal_set_optional(value);
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.optional)
+}
+
+// -------------------------------------------------------------------
+
+// FunctionSignature_Argument
+
+// string name = 1;
+inline void FunctionSignature_Argument::clear_name() {
+  name_.ClearToEmpty();
+}
+inline const std::string& FunctionSignature_Argument::name() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void FunctionSignature_Argument::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.name)
+}
+inline std::string* FunctionSignature_Argument::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.name)
+  return _s;
+}
+inline const std::string& FunctionSignature_Argument::_internal_name() const {
+  return name_.Get();
+}
+inline void FunctionSignature_Argument::_internal_set_name(const std::string& value) {
+  
+  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* FunctionSignature_Argument::_internal_mutable_name() {
+  
+  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* FunctionSignature_Argument::release_name() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.name)
+  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void FunctionSignature_Argument::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.name)
+}
+
+// .substrait.FunctionSignature.Argument.ValueArgument value = 2;
+inline bool FunctionSignature_Argument::_internal_has_value() const {
+  return argument_kind_case() == kValue;
+}
+inline bool FunctionSignature_Argument::has_value() const {
+  return _internal_has_value();
+}
+inline void FunctionSignature_Argument::set_has_value() {
+  _oneof_case_[0] = kValue;
+}
+inline void FunctionSignature_Argument::clear_value() {
+  if (_internal_has_value()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete argument_kind_.value_;
+    }
+    clear_has_argument_kind();
+  }
+}
+inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::release_value() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.value)
+  if (_internal_has_value()) {
+    clear_has_argument_kind();
+      ::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    argument_kind_.value_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::_internal_value() const {
+  return _internal_has_value()
+      ? *argument_kind_.value_
+      : reinterpret_cast< ::substrait::FunctionSignature_Argument_ValueArgument&>(::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_);
+}
+inline const ::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::value() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.value)
+  return _internal_value();
+}
+inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Argument.value)
+  if (_internal_has_value()) {
+    clear_has_argument_kind();
+    ::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_;
+    argument_kind_.value_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void FunctionSignature_Argument::unsafe_arena_set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value) {
+  clear_argument_kind();
+  if (value) {
+    set_has_value();
+    argument_kind_.value_ = value;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.value)
+}
+inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::_internal_mutable_value() {
+  if (!_internal_has_value()) {
+    clear_argument_kind();
+    set_has_value();
+    argument_kind_.value_ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_ValueArgument >(GetArenaForAllocation());
+  }
+  return argument_kind_.value_;
+}
+inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::mutable_value() {
+  ::substrait::FunctionSignature_Argument_ValueArgument* _msg = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.value)
+  return _msg;
+}
+
+// .substrait.FunctionSignature.Argument.TypeArgument type = 3;
+inline bool FunctionSignature_Argument::_internal_has_type() const {
+  return argument_kind_case() == kType;
+}
+inline bool FunctionSignature_Argument::has_type() const {
+  return _internal_has_type();
+}
+inline void FunctionSignature_Argument::set_has_type() {
+  _oneof_case_[0] = kType;
+}
+inline void FunctionSignature_Argument::clear_type() {
+  if (_internal_has_type()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete argument_kind_.type_;
+    }
+    clear_has_argument_kind();
+  }
+}
+inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::release_type() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.type)
+  if (_internal_has_type()) {
+    clear_has_argument_kind();
+      ::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    argument_kind_.type_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::_internal_type() const {
+  return _internal_has_type()
+      ? *argument_kind_.type_
+      : reinterpret_cast< ::substrait::FunctionSignature_Argument_TypeArgument&>(::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_);
+}
+inline const ::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::type() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.type)
+  return _internal_type();
+}
+inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::unsafe_arena_release_type() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Argument.type)
+  if (_internal_has_type()) {
+    clear_has_argument_kind();
+    ::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_;
+    argument_kind_.type_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void FunctionSignature_Argument::unsafe_arena_set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type) {
+  clear_argument_kind();
+  if (type) {
+    set_has_type();
+    argument_kind_.type_ = type;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.type)
+}
+inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::_internal_mutable_type() {
+  if (!_internal_has_type()) {
+    clear_argument_kind();
+    set_has_type();
+    argument_kind_.type_ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_TypeArgument >(GetArenaForAllocation());
+  }
+  return argument_kind_.type_;
+}
+inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::mutable_type() {
+  ::substrait::FunctionSignature_Argument_TypeArgument* _msg = _internal_mutable_type();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.type)
+  return _msg;
+}
+
+// .substrait.FunctionSignature.Argument.EnumArgument enum = 4;
+inline bool FunctionSignature_Argument::_internal_has_enum_() const {
+  return argument_kind_case() == kEnum;
+}
+inline bool FunctionSignature_Argument::has_enum_() const {
+  return _internal_has_enum_();
+}
+inline void FunctionSignature_Argument::set_has_enum_() {
+  _oneof_case_[0] = kEnum;
+}
+inline void FunctionSignature_Argument::clear_enum_() {
+  if (_internal_has_enum_()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete argument_kind_.enum__;
+    }
+    clear_has_argument_kind();
+  }
+}
+inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::release_enum_() {
+  // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.enum)
+  if (_internal_has_enum_()) {
+    clear_has_argument_kind();
+      ::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    argument_kind_.enum__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::_internal_enum_() const {
+  return _internal_has_enum_()
+      ? *argument_kind_.enum__
+      : reinterpret_cast< ::substrait::FunctionSignature_Argument_EnumArgument&>(::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_);
+}
+inline const ::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::enum_() const {
+  // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.enum)
+  return _internal_enum_();
+}
+inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::unsafe_arena_release_enum_() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Argument.enum)
+  if (_internal_has_enum_()) {
+    clear_has_argument_kind();
+    ::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__;
+    argument_kind_.enum__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void FunctionSignature_Argument::unsafe_arena_set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_) {
+  clear_argument_kind();
+  if (enum_) {
+    set_has_enum_();
+    argument_kind_.enum__ = enum_;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.enum)
+}
+inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::_internal_mutable_enum_() {
+  if (!_internal_has_enum_()) {
+    clear_argument_kind();
+    set_has_enum_();
+    argument_kind_.enum__ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_EnumArgument >(GetArenaForAllocation());
+  }
+  return argument_kind_.enum__;
+}
+inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::mutable_enum_() {
+  ::substrait::FunctionSignature_Argument_EnumArgument* _msg = _internal_mutable_enum_();
+  // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.enum)
+  return _msg;
+}
+
+inline bool FunctionSignature_Argument::has_argument_kind() const {
+  return argument_kind_case() != ARGUMENT_KIND_NOT_SET;
+}
+inline void FunctionSignature_Argument::clear_has_argument_kind() {
+  _oneof_case_[0] = ARGUMENT_KIND_NOT_SET;
+}
+inline FunctionSignature_Argument::ArgumentKindCase FunctionSignature_Argument::argument_kind_case() const {
+  return FunctionSignature_Argument::ArgumentKindCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// FunctionSignature
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace substrait
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>() {
+  return ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor();
+}
+template <> struct is_proto_enum< ::substrait::FunctionSignature_Window_WindowType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::substrait::FunctionSignature_Window_WindowType>() {
+  return ::substrait::FunctionSignature_Window_WindowType_descriptor();
+}
+template <> struct is_proto_enum< ::substrait::FunctionSignature_Implementation_Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::substrait::FunctionSignature_Implementation_Type>() {
+  return ::substrait::FunctionSignature_Implementation_Type_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2ffunction_2eproto
diff --git a/cpp/src/generated/substrait/parameterized_types.pb.cc b/cpp/src/generated/substrait/parameterized_types.pb.cc
new file mode 100644
index 000000000000..a37885aca41d
--- /dev/null
+++ b/cpp/src/generated/substrait/parameterized_types.pb.cc
@@ -0,0 +1,5353 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/parameterized_types.proto
+
+#include "substrait/parameterized_types.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace substrait {
+constexpr ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : bounds_()
+  , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct ParameterizedType_TypeParameterDefaultTypeInternal {
+  constexpr ParameterizedType_TypeParameterDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedType_TypeParameterDefaultTypeInternal() {}
+  union {
+    ParameterizedType_TypeParameter _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_TypeParameterDefaultTypeInternal _ParameterizedType_TypeParameter_default_instance_;
+constexpr ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , range_start_inclusive_(nullptr)
+  , range_end_exclusive_(nullptr){}
+struct ParameterizedType_IntegerParameterDefaultTypeInternal {
+  constexpr ParameterizedType_IntegerParameterDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedType_IntegerParameterDefaultTypeInternal() {}
+  union {
+    ParameterizedType_IntegerParameter _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_IntegerParameterDefaultTypeInternal _ParameterizedType_IntegerParameter_default_instance_;
+constexpr ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : value_(int64_t{0}){}
+struct ParameterizedType_NullableIntegerDefaultTypeInternal {
+  constexpr ParameterizedType_NullableIntegerDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedType_NullableIntegerDefaultTypeInternal() {}
+  union {
+    ParameterizedType_NullableInteger _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_NullableIntegerDefaultTypeInternal _ParameterizedType_NullableInteger_default_instance_;
+constexpr ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : length_(nullptr)
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct ParameterizedType_ParameterizedFixedCharDefaultTypeInternal {
+  constexpr ParameterizedType_ParameterizedFixedCharDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedType_ParameterizedFixedCharDefaultTypeInternal() {}
+  union {
+    ParameterizedType_ParameterizedFixedChar _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedFixedCharDefaultTypeInternal _ParameterizedType_ParameterizedFixedChar_default_instance_;
+constexpr ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : length_(nullptr)
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct ParameterizedType_ParameterizedVarCharDefaultTypeInternal {
+  constexpr ParameterizedType_ParameterizedVarCharDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedType_ParameterizedVarCharDefaultTypeInternal() {}
+  union {
+    ParameterizedType_ParameterizedVarChar _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedVarCharDefaultTypeInternal _ParameterizedType_ParameterizedVarChar_default_instance_;
+constexpr ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : length_(nullptr)
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal {
+  constexpr ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal() {}
+  union {
+    ParameterizedType_ParameterizedFixedBinary _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal _ParameterizedType_ParameterizedFixedBinary_default_instance_;
+constexpr ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : scale_(nullptr)
+  , precision_(nullptr)
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct ParameterizedType_ParameterizedDecimalDefaultTypeInternal {
+  constexpr ParameterizedType_ParameterizedDecimalDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedType_ParameterizedDecimalDefaultTypeInternal() {}
+  union {
+    ParameterizedType_ParameterizedDecimal _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedDecimalDefaultTypeInternal _ParameterizedType_ParameterizedDecimal_default_instance_;
+constexpr ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : types_()
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct ParameterizedType_ParameterizedStructDefaultTypeInternal {
+  constexpr ParameterizedType_ParameterizedStructDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedType_ParameterizedStructDefaultTypeInternal() {}
+  union {
+    ParameterizedType_ParameterizedStruct _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedStructDefaultTypeInternal _ParameterizedType_ParameterizedStruct_default_instance_;
+constexpr ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : names_()
+  , struct__(nullptr){}
+struct ParameterizedType_ParameterizedNamedStructDefaultTypeInternal {
+  constexpr ParameterizedType_ParameterizedNamedStructDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedType_ParameterizedNamedStructDefaultTypeInternal() {}
+  union {
+    ParameterizedType_ParameterizedNamedStruct _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedNamedStructDefaultTypeInternal _ParameterizedType_ParameterizedNamedStruct_default_instance_;
+constexpr ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_(nullptr)
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct ParameterizedType_ParameterizedListDefaultTypeInternal {
+  constexpr ParameterizedType_ParameterizedListDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedType_ParameterizedListDefaultTypeInternal() {}
+  union {
+    ParameterizedType_ParameterizedList _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedListDefaultTypeInternal _ParameterizedType_ParameterizedList_default_instance_;
+constexpr ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : key_(nullptr)
+  , value_(nullptr)
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct ParameterizedType_ParameterizedMapDefaultTypeInternal {
+  constexpr ParameterizedType_ParameterizedMapDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedType_ParameterizedMapDefaultTypeInternal() {}
+  union {
+    ParameterizedType_ParameterizedMap _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedMapDefaultTypeInternal _ParameterizedType_ParameterizedMap_default_instance_;
+constexpr ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct ParameterizedType_IntegerOptionDefaultTypeInternal {
+  constexpr ParameterizedType_IntegerOptionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedType_IntegerOptionDefaultTypeInternal() {}
+  union {
+    ParameterizedType_IntegerOption _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_IntegerOptionDefaultTypeInternal _ParameterizedType_IntegerOption_default_instance_;
+constexpr ParameterizedType::ParameterizedType(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct ParameterizedTypeDefaultTypeInternal {
+  constexpr ParameterizedTypeDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ParameterizedTypeDefaultTypeInternal() {}
+  union {
+    ParameterizedType _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedTypeDefaultTypeInternal _ParameterizedType_default_instance_;
+}  // namespace substrait
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[13];
+static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fparameterized_5ftypes_2eproto = nullptr;
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fparameterized_5ftypes_2eproto = nullptr;
+
+const uint32_t TableStruct_substrait_2fparameterized_5ftypes_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_TypeParameter, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_TypeParameter, name_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_TypeParameter, bounds_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, name_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, range_start_inclusive_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, range_end_exclusive_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_NullableInteger, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_NullableInteger, value_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, length_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, length_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, length_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, scale_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, precision_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, types_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedNamedStruct, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedNamedStruct, names_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedNamedStruct, struct__),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, key_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, value_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerOption, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerOption, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerOption, integer_type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType, kind_),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, -1, sizeof(::substrait::ParameterizedType_TypeParameter)},
+  { 8, -1, -1, sizeof(::substrait::ParameterizedType_IntegerParameter)},
+  { 17, -1, -1, sizeof(::substrait::ParameterizedType_NullableInteger)},
+  { 24, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedFixedChar)},
+  { 33, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedVarChar)},
+  { 42, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedFixedBinary)},
+  { 51, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedDecimal)},
+  { 61, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedStruct)},
+  { 70, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedNamedStruct)},
+  { 78, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedList)},
+  { 87, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedMap)},
+  { 97, -1, -1, sizeof(::substrait::ParameterizedType_IntegerOption)},
+  { 106, -1, -1, sizeof(::substrait::ParameterizedType)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_TypeParameter_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_IntegerParameter_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_NullableInteger_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_ParameterizedFixedChar_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_ParameterizedVarChar_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_ParameterizedFixedBinary_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_ParameterizedDecimal_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_ParameterizedStruct_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_ParameterizedNamedStruct_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_ParameterizedList_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_ParameterizedMap_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_IntegerOption_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ParameterizedType_default_instance_),
+};
+
+const char descriptor_table_protodef_substrait_2fparameterized_5ftypes_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n#substrait/parameterized_types.proto\022\ts"
+  "ubstrait\032\024substrait/type.proto\"\271\027\n\021Param"
+  "eterizedType\022\'\n\004bool\030\001 \001(\0132\027.substrait.T"
+  "ype.BooleanH\000\022 \n\002i8\030\002 \001(\0132\022.substrait.Ty"
+  "pe.I8H\000\022\"\n\003i16\030\003 \001(\0132\023.substrait.Type.I1"
+  "6H\000\022\"\n\003i32\030\005 \001(\0132\023.substrait.Type.I32H\000\022"
+  "\"\n\003i64\030\007 \001(\0132\023.substrait.Type.I64H\000\022$\n\004f"
+  "p32\030\n \001(\0132\024.substrait.Type.FP32H\000\022$\n\004fp6"
+  "4\030\013 \001(\0132\024.substrait.Type.FP64H\000\022(\n\006strin"
+  "g\030\014 \001(\0132\026.substrait.Type.StringH\000\022(\n\006bin"
+  "ary\030\r \001(\0132\026.substrait.Type.BinaryH\000\022.\n\tt"
+  "imestamp\030\016 \001(\0132\031.substrait.Type.Timestam"
+  "pH\000\022$\n\004date\030\020 \001(\0132\024.substrait.Type.DateH"
+  "\000\022$\n\004time\030\021 \001(\0132\024.substrait.Type.TimeH\000\022"
+  "5\n\rinterval_year\030\023 \001(\0132\034.substrait.Type."
+  "IntervalYearH\000\0223\n\014interval_day\030\024 \001(\0132\033.s"
+  "ubstrait.Type.IntervalDayH\000\0223\n\014timestamp"
+  "_tz\030\035 \001(\0132\033.substrait.Type.TimestampTZH\000"
+  "\022$\n\004uuid\030  \001(\0132\024.substrait.Type.UUIDH\000\022I"
+  "\n\nfixed_char\030\025 \001(\01323.substrait.Parameter"
+  "izedType.ParameterizedFixedCharH\000\022D\n\007var"
+  "char\030\026 \001(\01321.substrait.ParameterizedType"
+  ".ParameterizedVarCharH\000\022M\n\014fixed_binary\030"
+  "\027 \001(\01325.substrait.ParameterizedType.Para"
+  "meterizedFixedBinaryH\000\022D\n\007decimal\030\030 \001(\0132"
+  "1.substrait.ParameterizedType.Parameteri"
+  "zedDecimalH\000\022B\n\006struct\030\031 \001(\01320.substrait"
+  ".ParameterizedType.ParameterizedStructH\000"
+  "\022>\n\004list\030\033 \001(\0132..substrait.Parameterized"
+  "Type.ParameterizedListH\000\022<\n\003map\030\034 \001(\0132-."
+  "substrait.ParameterizedType.Parameterize"
+  "dMapH\000\022\036\n\024user_defined_pointer\030\037 \001(\rH\000\022D"
+  "\n\016type_parameter\030! \001(\0132*.substrait.Param"
+  "eterizedType.TypeParameterH\000\032K\n\rTypePara"
+  "meter\022\014\n\004name\030\001 \001(\t\022,\n\006bounds\030\002 \003(\0132\034.su"
+  "bstrait.ParameterizedType\032\270\001\n\020IntegerPar"
+  "ameter\022\014\n\004name\030\001 \001(\t\022K\n\025range_start_incl"
+  "usive\030\002 \001(\0132,.substrait.ParameterizedTyp"
+  "e.NullableInteger\022I\n\023range_end_exclusive"
+  "\030\003 \001(\0132,.substrait.ParameterizedType.Nul"
+  "lableInteger\032 \n\017NullableInteger\022\r\n\005value"
+  "\030\001 \001(\003\032\241\001\n\026ParameterizedFixedChar\022:\n\006len"
+  "gth\030\001 \001(\0132*.substrait.ParameterizedType."
+  "IntegerOption\022\031\n\021variation_pointer\030\002 \001(\r"
+  "\0220\n\013nullability\030\003 \001(\0162\033.substrait.Type.N"
+  "ullability\032\237\001\n\024ParameterizedVarChar\022:\n\006l"
+  "ength\030\001 \001(\0132*.substrait.ParameterizedTyp"
+  "e.IntegerOption\022\031\n\021variation_pointer\030\002 \001"
+  "(\r\0220\n\013nullability\030\003 \001(\0162\033.substrait.Type"
+  ".Nullability\032\243\001\n\030ParameterizedFixedBinar"
+  "y\022:\n\006length\030\001 \001(\0132*.substrait.Parameteri"
+  "zedType.IntegerOption\022\031\n\021variation_point"
+  "er\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033.substrai"
+  "t.Type.Nullability\032\335\001\n\024ParameterizedDeci"
+  "mal\0229\n\005scale\030\001 \001(\0132*.substrait.Parameter"
+  "izedType.IntegerOption\022=\n\tprecision\030\002 \001("
+  "\0132*.substrait.ParameterizedType.IntegerO"
+  "ption\022\031\n\021variation_pointer\030\003 \001(\r\0220\n\013null"
+  "ability\030\004 \001(\0162\033.substrait.Type.Nullabili"
+  "ty\032\217\001\n\023ParameterizedStruct\022+\n\005types\030\001 \003("
+  "\0132\034.substrait.ParameterizedType\022\031\n\021varia"
+  "tion_pointer\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162"
+  "\033.substrait.Type.Nullability\032k\n\030Paramete"
+  "rizedNamedStruct\022\r\n\005names\030\001 \003(\t\022@\n\006struc"
+  "t\030\002 \001(\01320.substrait.ParameterizedType.Pa"
+  "rameterizedStruct\032\214\001\n\021ParameterizedList\022"
+  "*\n\004type\030\001 \001(\0132\034.substrait.ParameterizedT"
+  "ype\022\031\n\021variation_pointer\030\002 \001(\r\0220\n\013nullab"
+  "ility\030\003 \001(\0162\033.substrait.Type.Nullability"
+  "\032\267\001\n\020ParameterizedMap\022)\n\003key\030\001 \001(\0132\034.sub"
+  "strait.ParameterizedType\022+\n\005value\030\002 \001(\0132"
+  "\034.substrait.ParameterizedType\022\031\n\021variati"
+  "on_pointer\030\003 \001(\r\0220\n\013nullability\030\004 \001(\0162\033."
+  "substrait.Type.Nullability\032v\n\rIntegerOpt"
+  "ion\022\021\n\007literal\030\001 \001(\005H\000\022B\n\tparameter\030\002 \001("
+  "\0132-.substrait.ParameterizedType.IntegerP"
+  "arameterH\000B\016\n\014integer_typeB\006\n\004kindB+\n\022io"
+  ".substrait.protoP\001\252\002\022Substrait.Protobufb"
+  "\006proto3"
+  ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2fparameterized_5ftypes_2eproto_deps[1] = {
+  &::descriptor_table_substrait_2ftype_2eproto,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fparameterized_5ftypes_2eproto = {
+  false, false, 3127, descriptor_table_protodef_substrait_2fparameterized_5ftypes_2eproto, "substrait/parameterized_types.proto", 
+  &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, descriptor_table_substrait_2fparameterized_5ftypes_2eproto_deps, 1, 13,
+  schemas, file_default_instances, TableStruct_substrait_2fparameterized_5ftypes_2eproto::offsets,
+  file_level_metadata_substrait_2fparameterized_5ftypes_2eproto, file_level_enum_descriptors_substrait_2fparameterized_5ftypes_2eproto, file_level_service_descriptors_substrait_2fparameterized_5ftypes_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter() {
+  return &descriptor_table_substrait_2fparameterized_5ftypes_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fparameterized_5ftypes_2eproto(&descriptor_table_substrait_2fparameterized_5ftypes_2eproto);
+namespace substrait {
+
+// ===================================================================
+
+class ParameterizedType_TypeParameter::_Internal {
+ public:
+};
+
+ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  bounds_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.TypeParameter)
+}
+ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(const ParameterizedType_TypeParameter& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      bounds_(from.bounds_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_name().empty()) {
+    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
+      GetArenaForAllocation());
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.TypeParameter)
+}
+
+inline void ParameterizedType_TypeParameter::SharedCtor() {
+name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+ParameterizedType_TypeParameter::~ParameterizedType_TypeParameter() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType.TypeParameter)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType_TypeParameter::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void ParameterizedType_TypeParameter::ArenaDtor(void* object) {
+  ParameterizedType_TypeParameter* _this = reinterpret_cast< ParameterizedType_TypeParameter* >(object);
+  (void)_this;
+}
+void ParameterizedType_TypeParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType_TypeParameter::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType_TypeParameter::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.TypeParameter)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  bounds_.Clear();
+  name_.ClearToEmpty();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType_TypeParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ParameterizedType.TypeParameter.name"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.ParameterizedType bounds = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_bounds(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType_TypeParameter::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.TypeParameter)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string name = 1;
+  if (!this->_internal_name().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.ParameterizedType.TypeParameter.name");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // repeated .substrait.ParameterizedType bounds = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_bounds_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_bounds(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.TypeParameter)
+  return target;
+}
+
+size_t ParameterizedType_TypeParameter::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.TypeParameter)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.ParameterizedType bounds = 2;
+  total_size += 1UL * this->_internal_bounds_size();
+  for (const auto& msg : this->bounds_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // string name = 1;
+  if (!this->_internal_name().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_TypeParameter::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType_TypeParameter::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_TypeParameter::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType_TypeParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType_TypeParameter *>(to)->MergeFrom(
+      static_cast<const ParameterizedType_TypeParameter &>(from));
+}
+
+
+void ParameterizedType_TypeParameter::MergeFrom(const ParameterizedType_TypeParameter& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.TypeParameter)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  bounds_.MergeFrom(from.bounds_);
+  if (!from._internal_name().empty()) {
+    _internal_set_name(from._internal_name());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType_TypeParameter::CopyFrom(const ParameterizedType_TypeParameter& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.TypeParameter)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType_TypeParameter::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType_TypeParameter::InternalSwap(ParameterizedType_TypeParameter* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  bounds_.InternalSwap(&other->bounds_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &name_, lhs_arena,
+      &other->name_, rhs_arena
+  );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_TypeParameter::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[0]);
+}
+
+// ===================================================================
+
+class ParameterizedType_IntegerParameter::_Internal {
+ public:
+  static const ::substrait::ParameterizedType_NullableInteger& range_start_inclusive(const ParameterizedType_IntegerParameter* msg);
+  static const ::substrait::ParameterizedType_NullableInteger& range_end_exclusive(const ParameterizedType_IntegerParameter* msg);
+};
+
+const ::substrait::ParameterizedType_NullableInteger&
+ParameterizedType_IntegerParameter::_Internal::range_start_inclusive(const ParameterizedType_IntegerParameter* msg) {
+  return *msg->range_start_inclusive_;
+}
+const ::substrait::ParameterizedType_NullableInteger&
+ParameterizedType_IntegerParameter::_Internal::range_end_exclusive(const ParameterizedType_IntegerParameter* msg) {
+  return *msg->range_end_exclusive_;
+}
+ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.IntegerParameter)
+}
+ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(const ParameterizedType_IntegerParameter& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_name().empty()) {
+    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
+      GetArenaForAllocation());
+  }
+  if (from._internal_has_range_start_inclusive()) {
+    range_start_inclusive_ = new ::substrait::ParameterizedType_NullableInteger(*from.range_start_inclusive_);
+  } else {
+    range_start_inclusive_ = nullptr;
+  }
+  if (from._internal_has_range_end_exclusive()) {
+    range_end_exclusive_ = new ::substrait::ParameterizedType_NullableInteger(*from.range_end_exclusive_);
+  } else {
+    range_end_exclusive_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.IntegerParameter)
+}
+
+inline void ParameterizedType_IntegerParameter::SharedCtor() {
+name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&range_start_inclusive_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&range_end_exclusive_) -
+    reinterpret_cast<char*>(&range_start_inclusive_)) + sizeof(range_end_exclusive_));
+}
+
+ParameterizedType_IntegerParameter::~ParameterizedType_IntegerParameter() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType.IntegerParameter)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType_IntegerParameter::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (this != internal_default_instance()) delete range_start_inclusive_;
+  if (this != internal_default_instance()) delete range_end_exclusive_;
+}
+
+void ParameterizedType_IntegerParameter::ArenaDtor(void* object) {
+  ParameterizedType_IntegerParameter* _this = reinterpret_cast< ParameterizedType_IntegerParameter* >(object);
+  (void)_this;
+}
+void ParameterizedType_IntegerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType_IntegerParameter::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType_IntegerParameter::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.IntegerParameter)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  name_.ClearToEmpty();
+  if (GetArenaForAllocation() == nullptr && range_start_inclusive_ != nullptr) {
+    delete range_start_inclusive_;
+  }
+  range_start_inclusive_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && range_end_exclusive_ != nullptr) {
+    delete range_end_exclusive_;
+  }
+  range_end_exclusive_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType_IntegerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ParameterizedType.IntegerParameter.name"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_range_start_inclusive(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_range_end_exclusive(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType_IntegerParameter::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.IntegerParameter)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string name = 1;
+  if (!this->_internal_name().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.ParameterizedType.IntegerParameter.name");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2;
+  if (this->_internal_has_range_start_inclusive()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::range_start_inclusive(this), target, stream);
+  }
+
+  // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3;
+  if (this->_internal_has_range_end_exclusive()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::range_end_exclusive(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.IntegerParameter)
+  return target;
+}
+
+size_t ParameterizedType_IntegerParameter::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.IntegerParameter)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string name = 1;
+  if (!this->_internal_name().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2;
+  if (this->_internal_has_range_start_inclusive()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *range_start_inclusive_);
+  }
+
+  // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3;
+  if (this->_internal_has_range_end_exclusive()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *range_end_exclusive_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_IntegerParameter::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType_IntegerParameter::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_IntegerParameter::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType_IntegerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType_IntegerParameter *>(to)->MergeFrom(
+      static_cast<const ParameterizedType_IntegerParameter &>(from));
+}
+
+
+void ParameterizedType_IntegerParameter::MergeFrom(const ParameterizedType_IntegerParameter& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.IntegerParameter)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_name().empty()) {
+    _internal_set_name(from._internal_name());
+  }
+  if (from._internal_has_range_start_inclusive()) {
+    _internal_mutable_range_start_inclusive()->::substrait::ParameterizedType_NullableInteger::MergeFrom(from._internal_range_start_inclusive());
+  }
+  if (from._internal_has_range_end_exclusive()) {
+    _internal_mutable_range_end_exclusive()->::substrait::ParameterizedType_NullableInteger::MergeFrom(from._internal_range_end_exclusive());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType_IntegerParameter::CopyFrom(const ParameterizedType_IntegerParameter& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.IntegerParameter)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType_IntegerParameter::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType_IntegerParameter::InternalSwap(ParameterizedType_IntegerParameter* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &name_, lhs_arena,
+      &other->name_, rhs_arena
+  );
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ParameterizedType_IntegerParameter, range_end_exclusive_)
+      + sizeof(ParameterizedType_IntegerParameter::range_end_exclusive_)
+      - PROTOBUF_FIELD_OFFSET(ParameterizedType_IntegerParameter, range_start_inclusive_)>(
+          reinterpret_cast<char*>(&range_start_inclusive_),
+          reinterpret_cast<char*>(&other->range_start_inclusive_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_IntegerParameter::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[1]);
+}
+
+// ===================================================================
+
+class ParameterizedType_NullableInteger::_Internal {
+ public:
+};
+
+ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.NullableInteger)
+}
+ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(const ParameterizedType_NullableInteger& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  value_ = from.value_;
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.NullableInteger)
+}
+
+inline void ParameterizedType_NullableInteger::SharedCtor() {
+value_ = int64_t{0};
+}
+
+ParameterizedType_NullableInteger::~ParameterizedType_NullableInteger() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType.NullableInteger)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType_NullableInteger::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ParameterizedType_NullableInteger::ArenaDtor(void* object) {
+  ParameterizedType_NullableInteger* _this = reinterpret_cast< ParameterizedType_NullableInteger* >(object);
+  (void)_this;
+}
+void ParameterizedType_NullableInteger::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType_NullableInteger::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType_NullableInteger::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.NullableInteger)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  value_ = int64_t{0};
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType_NullableInteger::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int64 value = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType_NullableInteger::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.NullableInteger)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int64 value = 1;
+  if (this->_internal_value() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_value(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.NullableInteger)
+  return target;
+}
+
+size_t ParameterizedType_NullableInteger::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.NullableInteger)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int64 value = 1;
+  if (this->_internal_value() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_value());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_NullableInteger::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType_NullableInteger::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_NullableInteger::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType_NullableInteger::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType_NullableInteger *>(to)->MergeFrom(
+      static_cast<const ParameterizedType_NullableInteger &>(from));
+}
+
+
+void ParameterizedType_NullableInteger::MergeFrom(const ParameterizedType_NullableInteger& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.NullableInteger)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_value() != 0) {
+    _internal_set_value(from._internal_value());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType_NullableInteger::CopyFrom(const ParameterizedType_NullableInteger& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.NullableInteger)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType_NullableInteger::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType_NullableInteger::InternalSwap(ParameterizedType_NullableInteger* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(value_, other->value_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_NullableInteger::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[2]);
+}
+
+// ===================================================================
+
+class ParameterizedType_ParameterizedFixedChar::_Internal {
+ public:
+  static const ::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedFixedChar* msg);
+};
+
+const ::substrait::ParameterizedType_IntegerOption&
+ParameterizedType_ParameterizedFixedChar::_Internal::length(const ParameterizedType_ParameterizedFixedChar* msg) {
+  return *msg->length_;
+}
+ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedFixedChar)
+}
+ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar(const ParameterizedType_ParameterizedFixedChar& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_length()) {
+    length_ = new ::substrait::ParameterizedType_IntegerOption(*from.length_);
+  } else {
+    length_ = nullptr;
+  }
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedFixedChar)
+}
+
+inline void ParameterizedType_ParameterizedFixedChar::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&length_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+}
+
+ParameterizedType_ParameterizedFixedChar::~ParameterizedType_ParameterizedFixedChar() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedFixedChar)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType_ParameterizedFixedChar::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete length_;
+}
+
+void ParameterizedType_ParameterizedFixedChar::ArenaDtor(void* object) {
+  ParameterizedType_ParameterizedFixedChar* _this = reinterpret_cast< ParameterizedType_ParameterizedFixedChar* >(object);
+  (void)_this;
+}
+void ParameterizedType_ParameterizedFixedChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType_ParameterizedFixedChar::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType_ParameterizedFixedChar::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedFixedChar)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
+    delete length_;
+  }
+  length_ = nullptr;
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType_ParameterizedFixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.ParameterizedType.IntegerOption length = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_length(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType_ParameterizedFixedChar::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedFixedChar)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType.IntegerOption length = 1;
+  if (this->_internal_has_length()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::length(this), target, stream);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedFixedChar)
+  return target;
+}
+
+size_t ParameterizedType_ParameterizedFixedChar::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedFixedChar)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType.IntegerOption length = 1;
+  if (this->_internal_has_length()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *length_);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedFixedChar::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType_ParameterizedFixedChar::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedFixedChar::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType_ParameterizedFixedChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType_ParameterizedFixedChar *>(to)->MergeFrom(
+      static_cast<const ParameterizedType_ParameterizedFixedChar &>(from));
+}
+
+
+void ParameterizedType_ParameterizedFixedChar::MergeFrom(const ParameterizedType_ParameterizedFixedChar& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedFixedChar)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_length()) {
+    _internal_mutable_length()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length());
+  }
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType_ParameterizedFixedChar::CopyFrom(const ParameterizedType_ParameterizedFixedChar& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedFixedChar)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType_ParameterizedFixedChar::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType_ParameterizedFixedChar::InternalSwap(ParameterizedType_ParameterizedFixedChar* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedChar, nullability_)
+      + sizeof(ParameterizedType_ParameterizedFixedChar::nullability_)
+      - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedChar, length_)>(
+          reinterpret_cast<char*>(&length_),
+          reinterpret_cast<char*>(&other->length_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedFixedChar::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[3]);
+}
+
+// ===================================================================
+
+class ParameterizedType_ParameterizedVarChar::_Internal {
+ public:
+  static const ::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedVarChar* msg);
+};
+
+const ::substrait::ParameterizedType_IntegerOption&
+ParameterizedType_ParameterizedVarChar::_Internal::length(const ParameterizedType_ParameterizedVarChar* msg) {
+  return *msg->length_;
+}
+ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedVarChar)
+}
+ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(const ParameterizedType_ParameterizedVarChar& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_length()) {
+    length_ = new ::substrait::ParameterizedType_IntegerOption(*from.length_);
+  } else {
+    length_ = nullptr;
+  }
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedVarChar)
+}
+
+inline void ParameterizedType_ParameterizedVarChar::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&length_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+}
+
+ParameterizedType_ParameterizedVarChar::~ParameterizedType_ParameterizedVarChar() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedVarChar)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType_ParameterizedVarChar::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete length_;
+}
+
+void ParameterizedType_ParameterizedVarChar::ArenaDtor(void* object) {
+  ParameterizedType_ParameterizedVarChar* _this = reinterpret_cast< ParameterizedType_ParameterizedVarChar* >(object);
+  (void)_this;
+}
+void ParameterizedType_ParameterizedVarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType_ParameterizedVarChar::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType_ParameterizedVarChar::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedVarChar)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
+    delete length_;
+  }
+  length_ = nullptr;
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType_ParameterizedVarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.ParameterizedType.IntegerOption length = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_length(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType_ParameterizedVarChar::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedVarChar)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType.IntegerOption length = 1;
+  if (this->_internal_has_length()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::length(this), target, stream);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedVarChar)
+  return target;
+}
+
+size_t ParameterizedType_ParameterizedVarChar::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedVarChar)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType.IntegerOption length = 1;
+  if (this->_internal_has_length()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *length_);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedVarChar::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType_ParameterizedVarChar::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedVarChar::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType_ParameterizedVarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType_ParameterizedVarChar *>(to)->MergeFrom(
+      static_cast<const ParameterizedType_ParameterizedVarChar &>(from));
+}
+
+
+void ParameterizedType_ParameterizedVarChar::MergeFrom(const ParameterizedType_ParameterizedVarChar& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedVarChar)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_length()) {
+    _internal_mutable_length()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length());
+  }
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType_ParameterizedVarChar::CopyFrom(const ParameterizedType_ParameterizedVarChar& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedVarChar)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType_ParameterizedVarChar::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType_ParameterizedVarChar::InternalSwap(ParameterizedType_ParameterizedVarChar* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedVarChar, nullability_)
+      + sizeof(ParameterizedType_ParameterizedVarChar::nullability_)
+      - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedVarChar, length_)>(
+          reinterpret_cast<char*>(&length_),
+          reinterpret_cast<char*>(&other->length_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedVarChar::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[4]);
+}
+
+// ===================================================================
+
+class ParameterizedType_ParameterizedFixedBinary::_Internal {
+ public:
+  static const ::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedFixedBinary* msg);
+};
+
+const ::substrait::ParameterizedType_IntegerOption&
+ParameterizedType_ParameterizedFixedBinary::_Internal::length(const ParameterizedType_ParameterizedFixedBinary* msg) {
+  return *msg->length_;
+}
+ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedFixedBinary)
+}
+ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary(const ParameterizedType_ParameterizedFixedBinary& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_length()) {
+    length_ = new ::substrait::ParameterizedType_IntegerOption(*from.length_);
+  } else {
+    length_ = nullptr;
+  }
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedFixedBinary)
+}
+
+inline void ParameterizedType_ParameterizedFixedBinary::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&length_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+}
+
+ParameterizedType_ParameterizedFixedBinary::~ParameterizedType_ParameterizedFixedBinary() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedFixedBinary)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType_ParameterizedFixedBinary::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete length_;
+}
+
+void ParameterizedType_ParameterizedFixedBinary::ArenaDtor(void* object) {
+  ParameterizedType_ParameterizedFixedBinary* _this = reinterpret_cast< ParameterizedType_ParameterizedFixedBinary* >(object);
+  (void)_this;
+}
+void ParameterizedType_ParameterizedFixedBinary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType_ParameterizedFixedBinary::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType_ParameterizedFixedBinary::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedFixedBinary)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
+    delete length_;
+  }
+  length_ = nullptr;
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType_ParameterizedFixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.ParameterizedType.IntegerOption length = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_length(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType_ParameterizedFixedBinary::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedFixedBinary)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType.IntegerOption length = 1;
+  if (this->_internal_has_length()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::length(this), target, stream);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedFixedBinary)
+  return target;
+}
+
+size_t ParameterizedType_ParameterizedFixedBinary::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedFixedBinary)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType.IntegerOption length = 1;
+  if (this->_internal_has_length()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *length_);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedFixedBinary::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType_ParameterizedFixedBinary::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedFixedBinary::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType_ParameterizedFixedBinary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType_ParameterizedFixedBinary *>(to)->MergeFrom(
+      static_cast<const ParameterizedType_ParameterizedFixedBinary &>(from));
+}
+
+
+void ParameterizedType_ParameterizedFixedBinary::MergeFrom(const ParameterizedType_ParameterizedFixedBinary& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedFixedBinary)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_length()) {
+    _internal_mutable_length()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length());
+  }
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType_ParameterizedFixedBinary::CopyFrom(const ParameterizedType_ParameterizedFixedBinary& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedFixedBinary)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType_ParameterizedFixedBinary::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType_ParameterizedFixedBinary::InternalSwap(ParameterizedType_ParameterizedFixedBinary* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedBinary, nullability_)
+      + sizeof(ParameterizedType_ParameterizedFixedBinary::nullability_)
+      - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedBinary, length_)>(
+          reinterpret_cast<char*>(&length_),
+          reinterpret_cast<char*>(&other->length_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedFixedBinary::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[5]);
+}
+
+// ===================================================================
+
+class ParameterizedType_ParameterizedDecimal::_Internal {
+ public:
+  static const ::substrait::ParameterizedType_IntegerOption& scale(const ParameterizedType_ParameterizedDecimal* msg);
+  static const ::substrait::ParameterizedType_IntegerOption& precision(const ParameterizedType_ParameterizedDecimal* msg);
+};
+
+const ::substrait::ParameterizedType_IntegerOption&
+ParameterizedType_ParameterizedDecimal::_Internal::scale(const ParameterizedType_ParameterizedDecimal* msg) {
+  return *msg->scale_;
+}
+const ::substrait::ParameterizedType_IntegerOption&
+ParameterizedType_ParameterizedDecimal::_Internal::precision(const ParameterizedType_ParameterizedDecimal* msg) {
+  return *msg->precision_;
+}
+ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedDecimal)
+}
+ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(const ParameterizedType_ParameterizedDecimal& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_scale()) {
+    scale_ = new ::substrait::ParameterizedType_IntegerOption(*from.scale_);
+  } else {
+    scale_ = nullptr;
+  }
+  if (from._internal_has_precision()) {
+    precision_ = new ::substrait::ParameterizedType_IntegerOption(*from.precision_);
+  } else {
+    precision_ = nullptr;
+  }
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedDecimal)
+}
+
+inline void ParameterizedType_ParameterizedDecimal::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&scale_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&scale_)) + sizeof(nullability_));
+}
+
+ParameterizedType_ParameterizedDecimal::~ParameterizedType_ParameterizedDecimal() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedDecimal)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType_ParameterizedDecimal::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete scale_;
+  if (this != internal_default_instance()) delete precision_;
+}
+
+void ParameterizedType_ParameterizedDecimal::ArenaDtor(void* object) {
+  ParameterizedType_ParameterizedDecimal* _this = reinterpret_cast< ParameterizedType_ParameterizedDecimal* >(object);
+  (void)_this;
+}
+void ParameterizedType_ParameterizedDecimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType_ParameterizedDecimal::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType_ParameterizedDecimal::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedDecimal)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && scale_ != nullptr) {
+    delete scale_;
+  }
+  scale_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && precision_ != nullptr) {
+    delete precision_;
+  }
+  precision_ = nullptr;
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType_ParameterizedDecimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.ParameterizedType.IntegerOption scale = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_scale(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.IntegerOption precision = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_precision(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType_ParameterizedDecimal::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedDecimal)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType.IntegerOption scale = 1;
+  if (this->_internal_has_scale()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::scale(this), target, stream);
+  }
+
+  // .substrait.ParameterizedType.IntegerOption precision = 2;
+  if (this->_internal_has_precision()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::precision(this), target, stream);
+  }
+
+  // uint32 variation_pointer = 3;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 4;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedDecimal)
+  return target;
+}
+
+size_t ParameterizedType_ParameterizedDecimal::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedDecimal)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType.IntegerOption scale = 1;
+  if (this->_internal_has_scale()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *scale_);
+  }
+
+  // .substrait.ParameterizedType.IntegerOption precision = 2;
+  if (this->_internal_has_precision()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *precision_);
+  }
+
+  // uint32 variation_pointer = 3;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 4;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedDecimal::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType_ParameterizedDecimal::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedDecimal::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType_ParameterizedDecimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType_ParameterizedDecimal *>(to)->MergeFrom(
+      static_cast<const ParameterizedType_ParameterizedDecimal &>(from));
+}
+
+
+void ParameterizedType_ParameterizedDecimal::MergeFrom(const ParameterizedType_ParameterizedDecimal& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedDecimal)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_scale()) {
+    _internal_mutable_scale()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_scale());
+  }
+  if (from._internal_has_precision()) {
+    _internal_mutable_precision()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_precision());
+  }
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType_ParameterizedDecimal::CopyFrom(const ParameterizedType_ParameterizedDecimal& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedDecimal)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType_ParameterizedDecimal::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType_ParameterizedDecimal::InternalSwap(ParameterizedType_ParameterizedDecimal* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedDecimal, nullability_)
+      + sizeof(ParameterizedType_ParameterizedDecimal::nullability_)
+      - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedDecimal, scale_)>(
+          reinterpret_cast<char*>(&scale_),
+          reinterpret_cast<char*>(&other->scale_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedDecimal::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[6]);
+}
+
+// ===================================================================
+
+class ParameterizedType_ParameterizedStruct::_Internal {
+ public:
+};
+
+ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  types_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedStruct)
+}
+ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(const ParameterizedType_ParameterizedStruct& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      types_(from.types_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedStruct)
+}
+
+inline void ParameterizedType_ParameterizedStruct::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&variation_pointer_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+}
+
+ParameterizedType_ParameterizedStruct::~ParameterizedType_ParameterizedStruct() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedStruct)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType_ParameterizedStruct::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ParameterizedType_ParameterizedStruct::ArenaDtor(void* object) {
+  ParameterizedType_ParameterizedStruct* _this = reinterpret_cast< ParameterizedType_ParameterizedStruct* >(object);
+  (void)_this;
+}
+void ParameterizedType_ParameterizedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType_ParameterizedStruct::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType_ParameterizedStruct::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedStruct)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  types_.Clear();
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType_ParameterizedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.ParameterizedType types = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_types(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType_ParameterizedStruct::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedStruct)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.ParameterizedType types = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_types_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_types(i), target, stream);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedStruct)
+  return target;
+}
+
+size_t ParameterizedType_ParameterizedStruct::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedStruct)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.ParameterizedType types = 1;
+  total_size += 1UL * this->_internal_types_size();
+  for (const auto& msg : this->types_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedStruct::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType_ParameterizedStruct::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedStruct::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType_ParameterizedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType_ParameterizedStruct *>(to)->MergeFrom(
+      static_cast<const ParameterizedType_ParameterizedStruct &>(from));
+}
+
+
+void ParameterizedType_ParameterizedStruct::MergeFrom(const ParameterizedType_ParameterizedStruct& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedStruct)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  types_.MergeFrom(from.types_);
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType_ParameterizedStruct::CopyFrom(const ParameterizedType_ParameterizedStruct& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedStruct)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType_ParameterizedStruct::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType_ParameterizedStruct::InternalSwap(ParameterizedType_ParameterizedStruct* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  types_.InternalSwap(&other->types_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedStruct, nullability_)
+      + sizeof(ParameterizedType_ParameterizedStruct::nullability_)
+      - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedStruct, variation_pointer_)>(
+          reinterpret_cast<char*>(&variation_pointer_),
+          reinterpret_cast<char*>(&other->variation_pointer_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedStruct::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[7]);
+}
+
+// ===================================================================
+
+class ParameterizedType_ParameterizedNamedStruct::_Internal {
+ public:
+  static const ::substrait::ParameterizedType_ParameterizedStruct& struct_(const ParameterizedType_ParameterizedNamedStruct* msg);
+};
+
+const ::substrait::ParameterizedType_ParameterizedStruct&
+ParameterizedType_ParameterizedNamedStruct::_Internal::struct_(const ParameterizedType_ParameterizedNamedStruct* msg) {
+  return *msg->struct__;
+}
+ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  names_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedNamedStruct)
+}
+ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct(const ParameterizedType_ParameterizedNamedStruct& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      names_(from.names_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_struct_()) {
+    struct__ = new ::substrait::ParameterizedType_ParameterizedStruct(*from.struct__);
+  } else {
+    struct__ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedNamedStruct)
+}
+
+inline void ParameterizedType_ParameterizedNamedStruct::SharedCtor() {
+struct__ = nullptr;
+}
+
+ParameterizedType_ParameterizedNamedStruct::~ParameterizedType_ParameterizedNamedStruct() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedNamedStruct)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType_ParameterizedNamedStruct::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete struct__;
+}
+
+void ParameterizedType_ParameterizedNamedStruct::ArenaDtor(void* object) {
+  ParameterizedType_ParameterizedNamedStruct* _this = reinterpret_cast< ParameterizedType_ParameterizedNamedStruct* >(object);
+  (void)_this;
+}
+void ParameterizedType_ParameterizedNamedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType_ParameterizedNamedStruct::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType_ParameterizedNamedStruct::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedNamedStruct)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  names_.Clear();
+  if (GetArenaForAllocation() == nullptr && struct__ != nullptr) {
+    delete struct__;
+  }
+  struct__ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType_ParameterizedNamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated string names = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_names();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ParameterizedType.ParameterizedNamedStruct.names"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.ParameterizedStruct struct = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType_ParameterizedNamedStruct::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedNamedStruct)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string names = 1;
+  for (int i = 0, n = this->_internal_names_size(); i < n; i++) {
+    const auto& s = this->_internal_names(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.ParameterizedType.ParameterizedNamedStruct.names");
+    target = stream->WriteString(1, s, target);
+  }
+
+  // .substrait.ParameterizedType.ParameterizedStruct struct = 2;
+  if (this->_internal_has_struct_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::struct_(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedNamedStruct)
+  return target;
+}
+
+size_t ParameterizedType_ParameterizedNamedStruct::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedNamedStruct)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string names = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size());
+  for (int i = 0, n = names_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      names_.Get(i));
+  }
+
+  // .substrait.ParameterizedType.ParameterizedStruct struct = 2;
+  if (this->_internal_has_struct_()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *struct__);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedNamedStruct::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType_ParameterizedNamedStruct::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedNamedStruct::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType_ParameterizedNamedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType_ParameterizedNamedStruct *>(to)->MergeFrom(
+      static_cast<const ParameterizedType_ParameterizedNamedStruct &>(from));
+}
+
+
+void ParameterizedType_ParameterizedNamedStruct::MergeFrom(const ParameterizedType_ParameterizedNamedStruct& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedNamedStruct)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  names_.MergeFrom(from.names_);
+  if (from._internal_has_struct_()) {
+    _internal_mutable_struct_()->::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType_ParameterizedNamedStruct::CopyFrom(const ParameterizedType_ParameterizedNamedStruct& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedNamedStruct)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType_ParameterizedNamedStruct::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType_ParameterizedNamedStruct::InternalSwap(ParameterizedType_ParameterizedNamedStruct* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  names_.InternalSwap(&other->names_);
+  swap(struct__, other->struct__);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedNamedStruct::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[8]);
+}
+
+// ===================================================================
+
+class ParameterizedType_ParameterizedList::_Internal {
+ public:
+  static const ::substrait::ParameterizedType& type(const ParameterizedType_ParameterizedList* msg);
+};
+
+const ::substrait::ParameterizedType&
+ParameterizedType_ParameterizedList::_Internal::type(const ParameterizedType_ParameterizedList* msg) {
+  return *msg->type_;
+}
+ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedList)
+}
+ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(const ParameterizedType_ParameterizedList& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_type()) {
+    type_ = new ::substrait::ParameterizedType(*from.type_);
+  } else {
+    type_ = nullptr;
+  }
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedList)
+}
+
+inline void ParameterizedType_ParameterizedList::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_)) + sizeof(nullability_));
+}
+
+ParameterizedType_ParameterizedList::~ParameterizedType_ParameterizedList() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedList)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType_ParameterizedList::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete type_;
+}
+
+void ParameterizedType_ParameterizedList::ArenaDtor(void* object) {
+  ParameterizedType_ParameterizedList* _this = reinterpret_cast< ParameterizedType_ParameterizedList* >(object);
+  (void)_this;
+}
+void ParameterizedType_ParameterizedList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType_ParameterizedList::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType_ParameterizedList::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedList)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
+    delete type_;
+  }
+  type_ = nullptr;
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType_ParameterizedList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.ParameterizedType type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType_ParameterizedList::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedList)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType type = 1;
+  if (this->_internal_has_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::type(this), target, stream);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedList)
+  return target;
+}
+
+size_t ParameterizedType_ParameterizedList::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedList)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType type = 1;
+  if (this->_internal_has_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *type_);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedList::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType_ParameterizedList::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedList::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType_ParameterizedList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType_ParameterizedList *>(to)->MergeFrom(
+      static_cast<const ParameterizedType_ParameterizedList &>(from));
+}
+
+
+void ParameterizedType_ParameterizedList::MergeFrom(const ParameterizedType_ParameterizedList& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedList)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_type()) {
+    _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type());
+  }
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType_ParameterizedList::CopyFrom(const ParameterizedType_ParameterizedList& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedList)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType_ParameterizedList::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType_ParameterizedList::InternalSwap(ParameterizedType_ParameterizedList* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedList, nullability_)
+      + sizeof(ParameterizedType_ParameterizedList::nullability_)
+      - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedList, type_)>(
+          reinterpret_cast<char*>(&type_),
+          reinterpret_cast<char*>(&other->type_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedList::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[9]);
+}
+
+// ===================================================================
+
+class ParameterizedType_ParameterizedMap::_Internal {
+ public:
+  static const ::substrait::ParameterizedType& key(const ParameterizedType_ParameterizedMap* msg);
+  static const ::substrait::ParameterizedType& value(const ParameterizedType_ParameterizedMap* msg);
+};
+
+const ::substrait::ParameterizedType&
+ParameterizedType_ParameterizedMap::_Internal::key(const ParameterizedType_ParameterizedMap* msg) {
+  return *msg->key_;
+}
+const ::substrait::ParameterizedType&
+ParameterizedType_ParameterizedMap::_Internal::value(const ParameterizedType_ParameterizedMap* msg) {
+  return *msg->value_;
+}
+ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedMap)
+}
+ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(const ParameterizedType_ParameterizedMap& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_key()) {
+    key_ = new ::substrait::ParameterizedType(*from.key_);
+  } else {
+    key_ = nullptr;
+  }
+  if (from._internal_has_value()) {
+    value_ = new ::substrait::ParameterizedType(*from.value_);
+  } else {
+    value_ = nullptr;
+  }
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedMap)
+}
+
+inline void ParameterizedType_ParameterizedMap::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&key_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&key_)) + sizeof(nullability_));
+}
+
+ParameterizedType_ParameterizedMap::~ParameterizedType_ParameterizedMap() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedMap)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType_ParameterizedMap::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete key_;
+  if (this != internal_default_instance()) delete value_;
+}
+
+void ParameterizedType_ParameterizedMap::ArenaDtor(void* object) {
+  ParameterizedType_ParameterizedMap* _this = reinterpret_cast< ParameterizedType_ParameterizedMap* >(object);
+  (void)_this;
+}
+void ParameterizedType_ParameterizedMap::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType_ParameterizedMap::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType_ParameterizedMap::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedMap)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && key_ != nullptr) {
+    delete key_;
+  }
+  key_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && value_ != nullptr) {
+    delete value_;
+  }
+  value_ = nullptr;
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType_ParameterizedMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.ParameterizedType key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType_ParameterizedMap::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedMap)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType key = 1;
+  if (this->_internal_has_key()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::key(this), target, stream);
+  }
+
+  // .substrait.ParameterizedType value = 2;
+  if (this->_internal_has_value()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::value(this), target, stream);
+  }
+
+  // uint32 variation_pointer = 3;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 4;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedMap)
+  return target;
+}
+
+size_t ParameterizedType_ParameterizedMap::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedMap)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.ParameterizedType key = 1;
+  if (this->_internal_has_key()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *key_);
+  }
+
+  // .substrait.ParameterizedType value = 2;
+  if (this->_internal_has_value()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *value_);
+  }
+
+  // uint32 variation_pointer = 3;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 4;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedMap::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType_ParameterizedMap::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedMap::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType_ParameterizedMap::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType_ParameterizedMap *>(to)->MergeFrom(
+      static_cast<const ParameterizedType_ParameterizedMap &>(from));
+}
+
+
+void ParameterizedType_ParameterizedMap::MergeFrom(const ParameterizedType_ParameterizedMap& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedMap)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_key()) {
+    _internal_mutable_key()->::substrait::ParameterizedType::MergeFrom(from._internal_key());
+  }
+  if (from._internal_has_value()) {
+    _internal_mutable_value()->::substrait::ParameterizedType::MergeFrom(from._internal_value());
+  }
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType_ParameterizedMap::CopyFrom(const ParameterizedType_ParameterizedMap& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedMap)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType_ParameterizedMap::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType_ParameterizedMap::InternalSwap(ParameterizedType_ParameterizedMap* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedMap, nullability_)
+      + sizeof(ParameterizedType_ParameterizedMap::nullability_)
+      - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedMap, key_)>(
+          reinterpret_cast<char*>(&key_),
+          reinterpret_cast<char*>(&other->key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedMap::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[10]);
+}
+
+// ===================================================================
+
+class ParameterizedType_IntegerOption::_Internal {
+ public:
+  static const ::substrait::ParameterizedType_IntegerParameter& parameter(const ParameterizedType_IntegerOption* msg);
+};
+
+const ::substrait::ParameterizedType_IntegerParameter&
+ParameterizedType_IntegerOption::_Internal::parameter(const ParameterizedType_IntegerOption* msg) {
+  return *msg->integer_type_.parameter_;
+}
+void ParameterizedType_IntegerOption::set_allocated_parameter(::substrait::ParameterizedType_IntegerParameter* parameter) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_integer_type();
+  if (parameter) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerParameter>::GetOwningArena(parameter);
+    if (message_arena != submessage_arena) {
+      parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, parameter, submessage_arena);
+    }
+    set_has_parameter();
+    integer_type_.parameter_ = parameter;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerOption.parameter)
+}
+ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.IntegerOption)
+}
+ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(const ParameterizedType_IntegerOption& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_integer_type();
+  switch (from.integer_type_case()) {
+    case kLiteral: {
+      _internal_set_literal(from._internal_literal());
+      break;
+    }
+    case kParameter: {
+      _internal_mutable_parameter()->::substrait::ParameterizedType_IntegerParameter::MergeFrom(from._internal_parameter());
+      break;
+    }
+    case INTEGER_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.IntegerOption)
+}
+
+inline void ParameterizedType_IntegerOption::SharedCtor() {
+clear_has_integer_type();
+}
+
+ParameterizedType_IntegerOption::~ParameterizedType_IntegerOption() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType.IntegerOption)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType_IntegerOption::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_integer_type()) {
+    clear_integer_type();
+  }
+}
+
+void ParameterizedType_IntegerOption::ArenaDtor(void* object) {
+  ParameterizedType_IntegerOption* _this = reinterpret_cast< ParameterizedType_IntegerOption* >(object);
+  (void)_this;
+}
+void ParameterizedType_IntegerOption::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType_IntegerOption::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType_IntegerOption::clear_integer_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.ParameterizedType.IntegerOption)
+  switch (integer_type_case()) {
+    case kLiteral: {
+      // No need to clear
+      break;
+    }
+    case kParameter: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete integer_type_.parameter_;
+      }
+      break;
+    }
+    case INTEGER_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = INTEGER_TYPE_NOT_SET;
+}
+
+
+void ParameterizedType_IntegerOption::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.IntegerOption)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_integer_type();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType_IntegerOption::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 literal = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          _internal_set_literal(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.IntegerParameter parameter = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_parameter(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType_IntegerOption::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.IntegerOption)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 literal = 1;
+  if (_internal_has_literal()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_literal(), target);
+  }
+
+  // .substrait.ParameterizedType.IntegerParameter parameter = 2;
+  if (_internal_has_parameter()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::parameter(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.IntegerOption)
+  return target;
+}
+
+size_t ParameterizedType_IntegerOption::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.IntegerOption)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (integer_type_case()) {
+    // int32 literal = 1;
+    case kLiteral: {
+      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_literal());
+      break;
+    }
+    // .substrait.ParameterizedType.IntegerParameter parameter = 2;
+    case kParameter: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *integer_type_.parameter_);
+      break;
+    }
+    case INTEGER_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_IntegerOption::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType_IntegerOption::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_IntegerOption::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType_IntegerOption::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType_IntegerOption *>(to)->MergeFrom(
+      static_cast<const ParameterizedType_IntegerOption &>(from));
+}
+
+
+void ParameterizedType_IntegerOption::MergeFrom(const ParameterizedType_IntegerOption& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.IntegerOption)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.integer_type_case()) {
+    case kLiteral: {
+      _internal_set_literal(from._internal_literal());
+      break;
+    }
+    case kParameter: {
+      _internal_mutable_parameter()->::substrait::ParameterizedType_IntegerParameter::MergeFrom(from._internal_parameter());
+      break;
+    }
+    case INTEGER_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType_IntegerOption::CopyFrom(const ParameterizedType_IntegerOption& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.IntegerOption)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType_IntegerOption::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType_IntegerOption::InternalSwap(ParameterizedType_IntegerOption* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(integer_type_, other->integer_type_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_IntegerOption::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[11]);
+}
+
+// ===================================================================
+
+class ParameterizedType::_Internal {
+ public:
+  static const ::substrait::Type_Boolean& bool_(const ParameterizedType* msg);
+  static const ::substrait::Type_I8& i8(const ParameterizedType* msg);
+  static const ::substrait::Type_I16& i16(const ParameterizedType* msg);
+  static const ::substrait::Type_I32& i32(const ParameterizedType* msg);
+  static const ::substrait::Type_I64& i64(const ParameterizedType* msg);
+  static const ::substrait::Type_FP32& fp32(const ParameterizedType* msg);
+  static const ::substrait::Type_FP64& fp64(const ParameterizedType* msg);
+  static const ::substrait::Type_String& string(const ParameterizedType* msg);
+  static const ::substrait::Type_Binary& binary(const ParameterizedType* msg);
+  static const ::substrait::Type_Timestamp& timestamp(const ParameterizedType* msg);
+  static const ::substrait::Type_Date& date(const ParameterizedType* msg);
+  static const ::substrait::Type_Time& time(const ParameterizedType* msg);
+  static const ::substrait::Type_IntervalYear& interval_year(const ParameterizedType* msg);
+  static const ::substrait::Type_IntervalDay& interval_day(const ParameterizedType* msg);
+  static const ::substrait::Type_TimestampTZ& timestamp_tz(const ParameterizedType* msg);
+  static const ::substrait::Type_UUID& uuid(const ParameterizedType* msg);
+  static const ::substrait::ParameterizedType_ParameterizedFixedChar& fixed_char(const ParameterizedType* msg);
+  static const ::substrait::ParameterizedType_ParameterizedVarChar& varchar(const ParameterizedType* msg);
+  static const ::substrait::ParameterizedType_ParameterizedFixedBinary& fixed_binary(const ParameterizedType* msg);
+  static const ::substrait::ParameterizedType_ParameterizedDecimal& decimal(const ParameterizedType* msg);
+  static const ::substrait::ParameterizedType_ParameterizedStruct& struct_(const ParameterizedType* msg);
+  static const ::substrait::ParameterizedType_ParameterizedList& list(const ParameterizedType* msg);
+  static const ::substrait::ParameterizedType_ParameterizedMap& map(const ParameterizedType* msg);
+  static const ::substrait::ParameterizedType_TypeParameter& type_parameter(const ParameterizedType* msg);
+};
+
+const ::substrait::Type_Boolean&
+ParameterizedType::_Internal::bool_(const ParameterizedType* msg) {
+  return *msg->kind_.bool__;
+}
+const ::substrait::Type_I8&
+ParameterizedType::_Internal::i8(const ParameterizedType* msg) {
+  return *msg->kind_.i8_;
+}
+const ::substrait::Type_I16&
+ParameterizedType::_Internal::i16(const ParameterizedType* msg) {
+  return *msg->kind_.i16_;
+}
+const ::substrait::Type_I32&
+ParameterizedType::_Internal::i32(const ParameterizedType* msg) {
+  return *msg->kind_.i32_;
+}
+const ::substrait::Type_I64&
+ParameterizedType::_Internal::i64(const ParameterizedType* msg) {
+  return *msg->kind_.i64_;
+}
+const ::substrait::Type_FP32&
+ParameterizedType::_Internal::fp32(const ParameterizedType* msg) {
+  return *msg->kind_.fp32_;
+}
+const ::substrait::Type_FP64&
+ParameterizedType::_Internal::fp64(const ParameterizedType* msg) {
+  return *msg->kind_.fp64_;
+}
+const ::substrait::Type_String&
+ParameterizedType::_Internal::string(const ParameterizedType* msg) {
+  return *msg->kind_.string_;
+}
+const ::substrait::Type_Binary&
+ParameterizedType::_Internal::binary(const ParameterizedType* msg) {
+  return *msg->kind_.binary_;
+}
+const ::substrait::Type_Timestamp&
+ParameterizedType::_Internal::timestamp(const ParameterizedType* msg) {
+  return *msg->kind_.timestamp_;
+}
+const ::substrait::Type_Date&
+ParameterizedType::_Internal::date(const ParameterizedType* msg) {
+  return *msg->kind_.date_;
+}
+const ::substrait::Type_Time&
+ParameterizedType::_Internal::time(const ParameterizedType* msg) {
+  return *msg->kind_.time_;
+}
+const ::substrait::Type_IntervalYear&
+ParameterizedType::_Internal::interval_year(const ParameterizedType* msg) {
+  return *msg->kind_.interval_year_;
+}
+const ::substrait::Type_IntervalDay&
+ParameterizedType::_Internal::interval_day(const ParameterizedType* msg) {
+  return *msg->kind_.interval_day_;
+}
+const ::substrait::Type_TimestampTZ&
+ParameterizedType::_Internal::timestamp_tz(const ParameterizedType* msg) {
+  return *msg->kind_.timestamp_tz_;
+}
+const ::substrait::Type_UUID&
+ParameterizedType::_Internal::uuid(const ParameterizedType* msg) {
+  return *msg->kind_.uuid_;
+}
+const ::substrait::ParameterizedType_ParameterizedFixedChar&
+ParameterizedType::_Internal::fixed_char(const ParameterizedType* msg) {
+  return *msg->kind_.fixed_char_;
+}
+const ::substrait::ParameterizedType_ParameterizedVarChar&
+ParameterizedType::_Internal::varchar(const ParameterizedType* msg) {
+  return *msg->kind_.varchar_;
+}
+const ::substrait::ParameterizedType_ParameterizedFixedBinary&
+ParameterizedType::_Internal::fixed_binary(const ParameterizedType* msg) {
+  return *msg->kind_.fixed_binary_;
+}
+const ::substrait::ParameterizedType_ParameterizedDecimal&
+ParameterizedType::_Internal::decimal(const ParameterizedType* msg) {
+  return *msg->kind_.decimal_;
+}
+const ::substrait::ParameterizedType_ParameterizedStruct&
+ParameterizedType::_Internal::struct_(const ParameterizedType* msg) {
+  return *msg->kind_.struct__;
+}
+const ::substrait::ParameterizedType_ParameterizedList&
+ParameterizedType::_Internal::list(const ParameterizedType* msg) {
+  return *msg->kind_.list_;
+}
+const ::substrait::ParameterizedType_ParameterizedMap&
+ParameterizedType::_Internal::map(const ParameterizedType* msg) {
+  return *msg->kind_.map_;
+}
+const ::substrait::ParameterizedType_TypeParameter&
+ParameterizedType::_Internal::type_parameter(const ParameterizedType* msg) {
+  return *msg->kind_.type_parameter_;
+}
+void ParameterizedType::set_allocated_bool_(::substrait::Type_Boolean* bool_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (bool_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bool_));
+    if (message_arena != submessage_arena) {
+      bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, bool_, submessage_arena);
+    }
+    set_has_bool_();
+    kind_.bool__ = bool_;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.bool)
+}
+void ParameterizedType::clear_bool_() {
+  if (_internal_has_bool_()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.bool__;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_i8(::substrait::Type_I8* i8) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (i8) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i8));
+    if (message_arena != submessage_arena) {
+      i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, i8, submessage_arena);
+    }
+    set_has_i8();
+    kind_.i8_ = i8;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.i8)
+}
+void ParameterizedType::clear_i8() {
+  if (_internal_has_i8()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.i8_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_i16(::substrait::Type_I16* i16) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (i16) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i16));
+    if (message_arena != submessage_arena) {
+      i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, i16, submessage_arena);
+    }
+    set_has_i16();
+    kind_.i16_ = i16;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.i16)
+}
+void ParameterizedType::clear_i16() {
+  if (_internal_has_i16()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.i16_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_i32(::substrait::Type_I32* i32) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (i32) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i32));
+    if (message_arena != submessage_arena) {
+      i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, i32, submessage_arena);
+    }
+    set_has_i32();
+    kind_.i32_ = i32;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.i32)
+}
+void ParameterizedType::clear_i32() {
+  if (_internal_has_i32()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.i32_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_i64(::substrait::Type_I64* i64) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (i64) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i64));
+    if (message_arena != submessage_arena) {
+      i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, i64, submessage_arena);
+    }
+    set_has_i64();
+    kind_.i64_ = i64;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.i64)
+}
+void ParameterizedType::clear_i64() {
+  if (_internal_has_i64()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.i64_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_fp32(::substrait::Type_FP32* fp32) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (fp32) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp32));
+    if (message_arena != submessage_arena) {
+      fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fp32, submessage_arena);
+    }
+    set_has_fp32();
+    kind_.fp32_ = fp32;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fp32)
+}
+void ParameterizedType::clear_fp32() {
+  if (_internal_has_fp32()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.fp32_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_fp64(::substrait::Type_FP64* fp64) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (fp64) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp64));
+    if (message_arena != submessage_arena) {
+      fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fp64, submessage_arena);
+    }
+    set_has_fp64();
+    kind_.fp64_ = fp64;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fp64)
+}
+void ParameterizedType::clear_fp64() {
+  if (_internal_has_fp64()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.fp64_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_string(::substrait::Type_String* string) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (string) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(string));
+    if (message_arena != submessage_arena) {
+      string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, string, submessage_arena);
+    }
+    set_has_string();
+    kind_.string_ = string;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.string)
+}
+void ParameterizedType::clear_string() {
+  if (_internal_has_string()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.string_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_binary(::substrait::Type_Binary* binary) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (binary) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(binary));
+    if (message_arena != submessage_arena) {
+      binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, binary, submessage_arena);
+    }
+    set_has_binary();
+    kind_.binary_ = binary;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.binary)
+}
+void ParameterizedType::clear_binary() {
+  if (_internal_has_binary()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.binary_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (timestamp) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp));
+    if (message_arena != submessage_arena) {
+      timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    set_has_timestamp();
+    kind_.timestamp_ = timestamp;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.timestamp)
+}
+void ParameterizedType::clear_timestamp() {
+  if (_internal_has_timestamp()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.timestamp_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_date(::substrait::Type_Date* date) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (date) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(date));
+    if (message_arena != submessage_arena) {
+      date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, date, submessage_arena);
+    }
+    set_has_date();
+    kind_.date_ = date;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.date)
+}
+void ParameterizedType::clear_date() {
+  if (_internal_has_date()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.date_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_time(::substrait::Type_Time* time) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (time) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(time));
+    if (message_arena != submessage_arena) {
+      time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, time, submessage_arena);
+    }
+    set_has_time();
+    kind_.time_ = time;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.time)
+}
+void ParameterizedType::clear_time() {
+  if (_internal_has_time()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.time_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (interval_year) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_year));
+    if (message_arena != submessage_arena) {
+      interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, interval_year, submessage_arena);
+    }
+    set_has_interval_year();
+    kind_.interval_year_ = interval_year;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.interval_year)
+}
+void ParameterizedType::clear_interval_year() {
+  if (_internal_has_interval_year()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.interval_year_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (interval_day) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_day));
+    if (message_arena != submessage_arena) {
+      interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, interval_day, submessage_arena);
+    }
+    set_has_interval_day();
+    kind_.interval_day_ = interval_day;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.interval_day)
+}
+void ParameterizedType::clear_interval_day() {
+  if (_internal_has_interval_day()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.interval_day_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (timestamp_tz) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_tz));
+    if (message_arena != submessage_arena) {
+      timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, timestamp_tz, submessage_arena);
+    }
+    set_has_timestamp_tz();
+    kind_.timestamp_tz_ = timestamp_tz;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.timestamp_tz)
+}
+void ParameterizedType::clear_timestamp_tz() {
+  if (_internal_has_timestamp_tz()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.timestamp_tz_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_uuid(::substrait::Type_UUID* uuid) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (uuid) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(uuid));
+    if (message_arena != submessage_arena) {
+      uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, uuid, submessage_arena);
+    }
+    set_has_uuid();
+    kind_.uuid_ = uuid;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.uuid)
+}
+void ParameterizedType::clear_uuid() {
+  if (_internal_has_uuid()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.uuid_;
+    }
+    clear_has_kind();
+  }
+}
+void ParameterizedType::set_allocated_fixed_char(::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (fixed_char) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedFixedChar>::GetOwningArena(fixed_char);
+    if (message_arena != submessage_arena) {
+      fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fixed_char, submessage_arena);
+    }
+    set_has_fixed_char();
+    kind_.fixed_char_ = fixed_char;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fixed_char)
+}
+void ParameterizedType::set_allocated_varchar(::substrait::ParameterizedType_ParameterizedVarChar* varchar) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (varchar) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedVarChar>::GetOwningArena(varchar);
+    if (message_arena != submessage_arena) {
+      varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, varchar, submessage_arena);
+    }
+    set_has_varchar();
+    kind_.varchar_ = varchar;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.varchar)
+}
+void ParameterizedType::set_allocated_fixed_binary(::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (fixed_binary) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedFixedBinary>::GetOwningArena(fixed_binary);
+    if (message_arena != submessage_arena) {
+      fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fixed_binary, submessage_arena);
+    }
+    set_has_fixed_binary();
+    kind_.fixed_binary_ = fixed_binary;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fixed_binary)
+}
+void ParameterizedType::set_allocated_decimal(::substrait::ParameterizedType_ParameterizedDecimal* decimal) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (decimal) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedDecimal>::GetOwningArena(decimal);
+    if (message_arena != submessage_arena) {
+      decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, decimal, submessage_arena);
+    }
+    set_has_decimal();
+    kind_.decimal_ = decimal;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.decimal)
+}
+void ParameterizedType::set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (struct_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedStruct>::GetOwningArena(struct_);
+    if (message_arena != submessage_arena) {
+      struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, struct_, submessage_arena);
+    }
+    set_has_struct_();
+    kind_.struct__ = struct_;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.struct)
+}
+void ParameterizedType::set_allocated_list(::substrait::ParameterizedType_ParameterizedList* list) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (list) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedList>::GetOwningArena(list);
+    if (message_arena != submessage_arena) {
+      list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, list, submessage_arena);
+    }
+    set_has_list();
+    kind_.list_ = list;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.list)
+}
+void ParameterizedType::set_allocated_map(::substrait::ParameterizedType_ParameterizedMap* map) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (map) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedMap>::GetOwningArena(map);
+    if (message_arena != submessage_arena) {
+      map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, map, submessage_arena);
+    }
+    set_has_map();
+    kind_.map_ = map;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.map)
+}
+void ParameterizedType::set_allocated_type_parameter(::substrait::ParameterizedType_TypeParameter* type_parameter) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (type_parameter) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_TypeParameter>::GetOwningArena(type_parameter);
+    if (message_arena != submessage_arena) {
+      type_parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, type_parameter, submessage_arena);
+    }
+    set_has_type_parameter();
+    kind_.type_parameter_ = type_parameter;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.type_parameter)
+}
+ParameterizedType::ParameterizedType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType)
+}
+ParameterizedType::ParameterizedType(const ParameterizedType& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_kind();
+  switch (from.kind_case()) {
+    case kBool: {
+      _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_());
+      break;
+    }
+    case kI8: {
+      _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8());
+      break;
+    }
+    case kI16: {
+      _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16());
+      break;
+    }
+    case kI32: {
+      _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32());
+      break;
+    }
+    case kI64: {
+      _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64());
+      break;
+    }
+    case kFp32: {
+      _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32());
+      break;
+    }
+    case kFp64: {
+      _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64());
+      break;
+    }
+    case kString: {
+      _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string());
+      break;
+    }
+    case kBinary: {
+      _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary());
+      break;
+    }
+    case kTimestamp: {
+      _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp());
+      break;
+    }
+    case kDate: {
+      _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date());
+      break;
+    }
+    case kTime: {
+      _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time());
+      break;
+    }
+    case kIntervalYear: {
+      _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year());
+      break;
+    }
+    case kIntervalDay: {
+      _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day());
+      break;
+    }
+    case kTimestampTz: {
+      _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz());
+      break;
+    }
+    case kUuid: {
+      _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid());
+      break;
+    }
+    case kFixedChar: {
+      _internal_mutable_fixed_char()->::substrait::ParameterizedType_ParameterizedFixedChar::MergeFrom(from._internal_fixed_char());
+      break;
+    }
+    case kVarchar: {
+      _internal_mutable_varchar()->::substrait::ParameterizedType_ParameterizedVarChar::MergeFrom(from._internal_varchar());
+      break;
+    }
+    case kFixedBinary: {
+      _internal_mutable_fixed_binary()->::substrait::ParameterizedType_ParameterizedFixedBinary::MergeFrom(from._internal_fixed_binary());
+      break;
+    }
+    case kDecimal: {
+      _internal_mutable_decimal()->::substrait::ParameterizedType_ParameterizedDecimal::MergeFrom(from._internal_decimal());
+      break;
+    }
+    case kStruct: {
+      _internal_mutable_struct_()->::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_());
+      break;
+    }
+    case kList: {
+      _internal_mutable_list()->::substrait::ParameterizedType_ParameterizedList::MergeFrom(from._internal_list());
+      break;
+    }
+    case kMap: {
+      _internal_mutable_map()->::substrait::ParameterizedType_ParameterizedMap::MergeFrom(from._internal_map());
+      break;
+    }
+    case kUserDefinedPointer: {
+      _internal_set_user_defined_pointer(from._internal_user_defined_pointer());
+      break;
+    }
+    case kTypeParameter: {
+      _internal_mutable_type_parameter()->::substrait::ParameterizedType_TypeParameter::MergeFrom(from._internal_type_parameter());
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType)
+}
+
+inline void ParameterizedType::SharedCtor() {
+clear_has_kind();
+}
+
+ParameterizedType::~ParameterizedType() {
+  // @@protoc_insertion_point(destructor:substrait.ParameterizedType)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ParameterizedType::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_kind()) {
+    clear_kind();
+  }
+}
+
+void ParameterizedType::ArenaDtor(void* object) {
+  ParameterizedType* _this = reinterpret_cast< ParameterizedType* >(object);
+  (void)_this;
+}
+void ParameterizedType::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ParameterizedType::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ParameterizedType::clear_kind() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.ParameterizedType)
+  switch (kind_case()) {
+    case kBool: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.bool__;
+      }
+      break;
+    }
+    case kI8: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.i8_;
+      }
+      break;
+    }
+    case kI16: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.i16_;
+      }
+      break;
+    }
+    case kI32: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.i32_;
+      }
+      break;
+    }
+    case kI64: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.i64_;
+      }
+      break;
+    }
+    case kFp32: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.fp32_;
+      }
+      break;
+    }
+    case kFp64: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.fp64_;
+      }
+      break;
+    }
+    case kString: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.string_;
+      }
+      break;
+    }
+    case kBinary: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.binary_;
+      }
+      break;
+    }
+    case kTimestamp: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.timestamp_;
+      }
+      break;
+    }
+    case kDate: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.date_;
+      }
+      break;
+    }
+    case kTime: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.time_;
+      }
+      break;
+    }
+    case kIntervalYear: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.interval_year_;
+      }
+      break;
+    }
+    case kIntervalDay: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.interval_day_;
+      }
+      break;
+    }
+    case kTimestampTz: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.timestamp_tz_;
+      }
+      break;
+    }
+    case kUuid: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.uuid_;
+      }
+      break;
+    }
+    case kFixedChar: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.fixed_char_;
+      }
+      break;
+    }
+    case kVarchar: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.varchar_;
+      }
+      break;
+    }
+    case kFixedBinary: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.fixed_binary_;
+      }
+      break;
+    }
+    case kDecimal: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.decimal_;
+      }
+      break;
+    }
+    case kStruct: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.struct__;
+      }
+      break;
+    }
+    case kList: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.list_;
+      }
+      break;
+    }
+    case kMap: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.map_;
+      }
+      break;
+    }
+    case kUserDefinedPointer: {
+      // No need to clear
+      break;
+    }
+    case kTypeParameter: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.type_parameter_;
+      }
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = KIND_NOT_SET;
+}
+
+
+void ParameterizedType::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_kind();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ParameterizedType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Type.Boolean bool = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.I8 i8 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.I16 i16 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.I32 i32 = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.I64 i64 = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.FP32 fp32 = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.FP64 fp64 = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.String string = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          ptr = ctx->ParseMessage(_internal_mutable_string(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Binary binary = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Timestamp timestamp = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
+          ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Date date = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          ptr = ctx->ParseMessage(_internal_mutable_date(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Time time = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_time(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.IntervalYear interval_year = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.IntervalDay interval_day = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
+          ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
+          ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 194)) {
+          ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.ParameterizedStruct struct = 25;
+      case 25:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 202)) {
+          ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.ParameterizedList list = 27;
+      case 27:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 218)) {
+          ptr = ctx->ParseMessage(_internal_mutable_list(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.ParameterizedMap map = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 226)) {
+          ptr = ctx->ParseMessage(_internal_mutable_map(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.TimestampTZ timestamp_tz = 29;
+      case 29:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 234)) {
+          ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 user_defined_pointer = 31;
+      case 31:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
+          _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.UUID uuid = 32;
+      case 32:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 2)) {
+          ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ParameterizedType.TypeParameter type_parameter = 33;
+      case 33:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_type_parameter(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ParameterizedType::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Type.Boolean bool = 1;
+  if (_internal_has_bool_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::bool_(this), target, stream);
+  }
+
+  // .substrait.Type.I8 i8 = 2;
+  if (_internal_has_i8()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::i8(this), target, stream);
+  }
+
+  // .substrait.Type.I16 i16 = 3;
+  if (_internal_has_i16()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::i16(this), target, stream);
+  }
+
+  // .substrait.Type.I32 i32 = 5;
+  if (_internal_has_i32()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        5, _Internal::i32(this), target, stream);
+  }
+
+  // .substrait.Type.I64 i64 = 7;
+  if (_internal_has_i64()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        7, _Internal::i64(this), target, stream);
+  }
+
+  // .substrait.Type.FP32 fp32 = 10;
+  if (_internal_has_fp32()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::fp32(this), target, stream);
+  }
+
+  // .substrait.Type.FP64 fp64 = 11;
+  if (_internal_has_fp64()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        11, _Internal::fp64(this), target, stream);
+  }
+
+  // .substrait.Type.String string = 12;
+  if (_internal_has_string()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        12, _Internal::string(this), target, stream);
+  }
+
+  // .substrait.Type.Binary binary = 13;
+  if (_internal_has_binary()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        13, _Internal::binary(this), target, stream);
+  }
+
+  // .substrait.Type.Timestamp timestamp = 14;
+  if (_internal_has_timestamp()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        14, _Internal::timestamp(this), target, stream);
+  }
+
+  // .substrait.Type.Date date = 16;
+  if (_internal_has_date()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        16, _Internal::date(this), target, stream);
+  }
+
+  // .substrait.Type.Time time = 17;
+  if (_internal_has_time()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        17, _Internal::time(this), target, stream);
+  }
+
+  // .substrait.Type.IntervalYear interval_year = 19;
+  if (_internal_has_interval_year()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        19, _Internal::interval_year(this), target, stream);
+  }
+
+  // .substrait.Type.IntervalDay interval_day = 20;
+  if (_internal_has_interval_day()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        20, _Internal::interval_day(this), target, stream);
+  }
+
+  // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21;
+  if (_internal_has_fixed_char()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        21, _Internal::fixed_char(this), target, stream);
+  }
+
+  // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22;
+  if (_internal_has_varchar()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        22, _Internal::varchar(this), target, stream);
+  }
+
+  // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23;
+  if (_internal_has_fixed_binary()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        23, _Internal::fixed_binary(this), target, stream);
+  }
+
+  // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24;
+  if (_internal_has_decimal()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        24, _Internal::decimal(this), target, stream);
+  }
+
+  // .substrait.ParameterizedType.ParameterizedStruct struct = 25;
+  if (_internal_has_struct_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        25, _Internal::struct_(this), target, stream);
+  }
+
+  // .substrait.ParameterizedType.ParameterizedList list = 27;
+  if (_internal_has_list()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        27, _Internal::list(this), target, stream);
+  }
+
+  // .substrait.ParameterizedType.ParameterizedMap map = 28;
+  if (_internal_has_map()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        28, _Internal::map(this), target, stream);
+  }
+
+  // .substrait.Type.TimestampTZ timestamp_tz = 29;
+  if (_internal_has_timestamp_tz()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        29, _Internal::timestamp_tz(this), target, stream);
+  }
+
+  // uint32 user_defined_pointer = 31;
+  if (_internal_has_user_defined_pointer()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_pointer(), target);
+  }
+
+  // .substrait.Type.UUID uuid = 32;
+  if (_internal_has_uuid()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        32, _Internal::uuid(this), target, stream);
+  }
+
+  // .substrait.ParameterizedType.TypeParameter type_parameter = 33;
+  if (_internal_has_type_parameter()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        33, _Internal::type_parameter(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType)
+  return target;
+}
+
+size_t ParameterizedType::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (kind_case()) {
+    // .substrait.Type.Boolean bool = 1;
+    case kBool: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.bool__);
+      break;
+    }
+    // .substrait.Type.I8 i8 = 2;
+    case kI8: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.i8_);
+      break;
+    }
+    // .substrait.Type.I16 i16 = 3;
+    case kI16: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.i16_);
+      break;
+    }
+    // .substrait.Type.I32 i32 = 5;
+    case kI32: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.i32_);
+      break;
+    }
+    // .substrait.Type.I64 i64 = 7;
+    case kI64: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.i64_);
+      break;
+    }
+    // .substrait.Type.FP32 fp32 = 10;
+    case kFp32: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.fp32_);
+      break;
+    }
+    // .substrait.Type.FP64 fp64 = 11;
+    case kFp64: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.fp64_);
+      break;
+    }
+    // .substrait.Type.String string = 12;
+    case kString: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.string_);
+      break;
+    }
+    // .substrait.Type.Binary binary = 13;
+    case kBinary: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.binary_);
+      break;
+    }
+    // .substrait.Type.Timestamp timestamp = 14;
+    case kTimestamp: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.timestamp_);
+      break;
+    }
+    // .substrait.Type.Date date = 16;
+    case kDate: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.date_);
+      break;
+    }
+    // .substrait.Type.Time time = 17;
+    case kTime: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.time_);
+      break;
+    }
+    // .substrait.Type.IntervalYear interval_year = 19;
+    case kIntervalYear: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.interval_year_);
+      break;
+    }
+    // .substrait.Type.IntervalDay interval_day = 20;
+    case kIntervalDay: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.interval_day_);
+      break;
+    }
+    // .substrait.Type.TimestampTZ timestamp_tz = 29;
+    case kTimestampTz: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.timestamp_tz_);
+      break;
+    }
+    // .substrait.Type.UUID uuid = 32;
+    case kUuid: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.uuid_);
+      break;
+    }
+    // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21;
+    case kFixedChar: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.fixed_char_);
+      break;
+    }
+    // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22;
+    case kVarchar: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.varchar_);
+      break;
+    }
+    // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23;
+    case kFixedBinary: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.fixed_binary_);
+      break;
+    }
+    // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24;
+    case kDecimal: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.decimal_);
+      break;
+    }
+    // .substrait.ParameterizedType.ParameterizedStruct struct = 25;
+    case kStruct: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.struct__);
+      break;
+    }
+    // .substrait.ParameterizedType.ParameterizedList list = 27;
+    case kList: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.list_);
+      break;
+    }
+    // .substrait.ParameterizedType.ParameterizedMap map = 28;
+    case kMap: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.map_);
+      break;
+    }
+    // uint32 user_defined_pointer = 31;
+    case kUserDefinedPointer: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
+          this->_internal_user_defined_pointer());
+      break;
+    }
+    // .substrait.ParameterizedType.TypeParameter type_parameter = 33;
+    case kTypeParameter: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.type_parameter_);
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ParameterizedType::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType::GetClassData() const { return &_class_data_; }
+
+void ParameterizedType::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ParameterizedType *>(to)->MergeFrom(
+      static_cast<const ParameterizedType &>(from));
+}
+
+
+void ParameterizedType::MergeFrom(const ParameterizedType& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.kind_case()) {
+    case kBool: {
+      _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_());
+      break;
+    }
+    case kI8: {
+      _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8());
+      break;
+    }
+    case kI16: {
+      _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16());
+      break;
+    }
+    case kI32: {
+      _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32());
+      break;
+    }
+    case kI64: {
+      _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64());
+      break;
+    }
+    case kFp32: {
+      _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32());
+      break;
+    }
+    case kFp64: {
+      _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64());
+      break;
+    }
+    case kString: {
+      _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string());
+      break;
+    }
+    case kBinary: {
+      _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary());
+      break;
+    }
+    case kTimestamp: {
+      _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp());
+      break;
+    }
+    case kDate: {
+      _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date());
+      break;
+    }
+    case kTime: {
+      _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time());
+      break;
+    }
+    case kIntervalYear: {
+      _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year());
+      break;
+    }
+    case kIntervalDay: {
+      _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day());
+      break;
+    }
+    case kTimestampTz: {
+      _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz());
+      break;
+    }
+    case kUuid: {
+      _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid());
+      break;
+    }
+    case kFixedChar: {
+      _internal_mutable_fixed_char()->::substrait::ParameterizedType_ParameterizedFixedChar::MergeFrom(from._internal_fixed_char());
+      break;
+    }
+    case kVarchar: {
+      _internal_mutable_varchar()->::substrait::ParameterizedType_ParameterizedVarChar::MergeFrom(from._internal_varchar());
+      break;
+    }
+    case kFixedBinary: {
+      _internal_mutable_fixed_binary()->::substrait::ParameterizedType_ParameterizedFixedBinary::MergeFrom(from._internal_fixed_binary());
+      break;
+    }
+    case kDecimal: {
+      _internal_mutable_decimal()->::substrait::ParameterizedType_ParameterizedDecimal::MergeFrom(from._internal_decimal());
+      break;
+    }
+    case kStruct: {
+      _internal_mutable_struct_()->::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_());
+      break;
+    }
+    case kList: {
+      _internal_mutable_list()->::substrait::ParameterizedType_ParameterizedList::MergeFrom(from._internal_list());
+      break;
+    }
+    case kMap: {
+      _internal_mutable_map()->::substrait::ParameterizedType_ParameterizedMap::MergeFrom(from._internal_map());
+      break;
+    }
+    case kUserDefinedPointer: {
+      _internal_set_user_defined_pointer(from._internal_user_defined_pointer());
+      break;
+    }
+    case kTypeParameter: {
+      _internal_mutable_type_parameter()->::substrait::ParameterizedType_TypeParameter::MergeFrom(from._internal_type_parameter());
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ParameterizedType::CopyFrom(const ParameterizedType& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParameterizedType::IsInitialized() const {
+  return true;
+}
+
+void ParameterizedType::InternalSwap(ParameterizedType* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(kind_, other->kind_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once,
+      file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[12]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_TypeParameter* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_TypeParameter >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType_TypeParameter >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_IntegerParameter* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_IntegerParameter >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType_IntegerParameter >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_NullableInteger* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_NullableInteger >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType_NullableInteger >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedFixedChar* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedChar >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedFixedChar >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedVarChar* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedVarChar >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedVarChar >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedFixedBinary* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedBinary >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedFixedBinary >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedDecimal* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedDecimal >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedDecimal >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedStruct* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedStruct >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedStruct >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedNamedStruct* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedNamedStruct >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedNamedStruct >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedList* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedList >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedList >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedMap* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedMap >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedMap >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_IntegerOption* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_IntegerOption >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType_IntegerOption >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType* Arena::CreateMaybeMessage< ::substrait::ParameterizedType >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ParameterizedType >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/cpp/src/generated/substrait/parameterized_types.pb.h b/cpp/src/generated/substrait/parameterized_types.pb.h
new file mode 100644
index 000000000000..ae85f689870b
--- /dev/null
+++ b/cpp/src/generated/substrait/parameterized_types.pb.h
@@ -0,0 +1,6437 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/parameterized_types.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fparameterized_5ftypes_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fparameterized_5ftypes_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3019000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3019003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "substrait/type.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_substrait_2fparameterized_5ftypes_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_substrait_2fparameterized_5ftypes_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[13]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fparameterized_5ftypes_2eproto;
+namespace substrait {
+class ParameterizedType;
+struct ParameterizedTypeDefaultTypeInternal;
+extern ParameterizedTypeDefaultTypeInternal _ParameterizedType_default_instance_;
+class ParameterizedType_IntegerOption;
+struct ParameterizedType_IntegerOptionDefaultTypeInternal;
+extern ParameterizedType_IntegerOptionDefaultTypeInternal _ParameterizedType_IntegerOption_default_instance_;
+class ParameterizedType_IntegerParameter;
+struct ParameterizedType_IntegerParameterDefaultTypeInternal;
+extern ParameterizedType_IntegerParameterDefaultTypeInternal _ParameterizedType_IntegerParameter_default_instance_;
+class ParameterizedType_NullableInteger;
+struct ParameterizedType_NullableIntegerDefaultTypeInternal;
+extern ParameterizedType_NullableIntegerDefaultTypeInternal _ParameterizedType_NullableInteger_default_instance_;
+class ParameterizedType_ParameterizedDecimal;
+struct ParameterizedType_ParameterizedDecimalDefaultTypeInternal;
+extern ParameterizedType_ParameterizedDecimalDefaultTypeInternal _ParameterizedType_ParameterizedDecimal_default_instance_;
+class ParameterizedType_ParameterizedFixedBinary;
+struct ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal;
+extern ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal _ParameterizedType_ParameterizedFixedBinary_default_instance_;
+class ParameterizedType_ParameterizedFixedChar;
+struct ParameterizedType_ParameterizedFixedCharDefaultTypeInternal;
+extern ParameterizedType_ParameterizedFixedCharDefaultTypeInternal _ParameterizedType_ParameterizedFixedChar_default_instance_;
+class ParameterizedType_ParameterizedList;
+struct ParameterizedType_ParameterizedListDefaultTypeInternal;
+extern ParameterizedType_ParameterizedListDefaultTypeInternal _ParameterizedType_ParameterizedList_default_instance_;
+class ParameterizedType_ParameterizedMap;
+struct ParameterizedType_ParameterizedMapDefaultTypeInternal;
+extern ParameterizedType_ParameterizedMapDefaultTypeInternal _ParameterizedType_ParameterizedMap_default_instance_;
+class ParameterizedType_ParameterizedNamedStruct;
+struct ParameterizedType_ParameterizedNamedStructDefaultTypeInternal;
+extern ParameterizedType_ParameterizedNamedStructDefaultTypeInternal _ParameterizedType_ParameterizedNamedStruct_default_instance_;
+class ParameterizedType_ParameterizedStruct;
+struct ParameterizedType_ParameterizedStructDefaultTypeInternal;
+extern ParameterizedType_ParameterizedStructDefaultTypeInternal _ParameterizedType_ParameterizedStruct_default_instance_;
+class ParameterizedType_ParameterizedVarChar;
+struct ParameterizedType_ParameterizedVarCharDefaultTypeInternal;
+extern ParameterizedType_ParameterizedVarCharDefaultTypeInternal _ParameterizedType_ParameterizedVarChar_default_instance_;
+class ParameterizedType_TypeParameter;
+struct ParameterizedType_TypeParameterDefaultTypeInternal;
+extern ParameterizedType_TypeParameterDefaultTypeInternal _ParameterizedType_TypeParameter_default_instance_;
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> ::substrait::ParameterizedType* Arena::CreateMaybeMessage<::substrait::ParameterizedType>(Arena*);
+template<> ::substrait::ParameterizedType_IntegerOption* Arena::CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(Arena*);
+template<> ::substrait::ParameterizedType_IntegerParameter* Arena::CreateMaybeMessage<::substrait::ParameterizedType_IntegerParameter>(Arena*);
+template<> ::substrait::ParameterizedType_NullableInteger* Arena::CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(Arena*);
+template<> ::substrait::ParameterizedType_ParameterizedDecimal* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedDecimal>(Arena*);
+template<> ::substrait::ParameterizedType_ParameterizedFixedBinary* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedFixedBinary>(Arena*);
+template<> ::substrait::ParameterizedType_ParameterizedFixedChar* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedFixedChar>(Arena*);
+template<> ::substrait::ParameterizedType_ParameterizedList* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedList>(Arena*);
+template<> ::substrait::ParameterizedType_ParameterizedMap* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedMap>(Arena*);
+template<> ::substrait::ParameterizedType_ParameterizedNamedStruct* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedNamedStruct>(Arena*);
+template<> ::substrait::ParameterizedType_ParameterizedStruct* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedStruct>(Arena*);
+template<> ::substrait::ParameterizedType_ParameterizedVarChar* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedVarChar>(Arena*);
+template<> ::substrait::ParameterizedType_TypeParameter* Arena::CreateMaybeMessage<::substrait::ParameterizedType_TypeParameter>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace substrait {
+
+// ===================================================================
+
+class ParameterizedType_TypeParameter final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.TypeParameter) */ {
+ public:
+  inline ParameterizedType_TypeParameter() : ParameterizedType_TypeParameter(nullptr) {}
+  ~ParameterizedType_TypeParameter() override;
+  explicit constexpr ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType_TypeParameter(const ParameterizedType_TypeParameter& from);
+  ParameterizedType_TypeParameter(ParameterizedType_TypeParameter&& from) noexcept
+    : ParameterizedType_TypeParameter() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType_TypeParameter& operator=(const ParameterizedType_TypeParameter& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType_TypeParameter& operator=(ParameterizedType_TypeParameter&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType_TypeParameter& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ParameterizedType_TypeParameter* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType_TypeParameter*>(
+               &_ParameterizedType_TypeParameter_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ParameterizedType_TypeParameter& a, ParameterizedType_TypeParameter& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType_TypeParameter* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType_TypeParameter* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType_TypeParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType_TypeParameter>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType_TypeParameter& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType_TypeParameter& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType_TypeParameter* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType.TypeParameter";
+  }
+  protected:
+  explicit ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBoundsFieldNumber = 2,
+    kNameFieldNumber = 1,
+  };
+  // repeated .substrait.ParameterizedType bounds = 2;
+  int bounds_size() const;
+  private:
+  int _internal_bounds_size() const;
+  public:
+  void clear_bounds();
+  ::substrait::ParameterizedType* mutable_bounds(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >*
+      mutable_bounds();
+  private:
+  const ::substrait::ParameterizedType& _internal_bounds(int index) const;
+  ::substrait::ParameterizedType* _internal_add_bounds();
+  public:
+  const ::substrait::ParameterizedType& bounds(int index) const;
+  ::substrait::ParameterizedType* add_bounds();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >&
+      bounds() const;
+
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.TypeParameter)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType > bounds_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ParameterizedType_IntegerParameter final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.IntegerParameter) */ {
+ public:
+  inline ParameterizedType_IntegerParameter() : ParameterizedType_IntegerParameter(nullptr) {}
+  ~ParameterizedType_IntegerParameter() override;
+  explicit constexpr ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType_IntegerParameter(const ParameterizedType_IntegerParameter& from);
+  ParameterizedType_IntegerParameter(ParameterizedType_IntegerParameter&& from) noexcept
+    : ParameterizedType_IntegerParameter() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType_IntegerParameter& operator=(const ParameterizedType_IntegerParameter& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType_IntegerParameter& operator=(ParameterizedType_IntegerParameter&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType_IntegerParameter& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ParameterizedType_IntegerParameter* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType_IntegerParameter*>(
+               &_ParameterizedType_IntegerParameter_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ParameterizedType_IntegerParameter& a, ParameterizedType_IntegerParameter& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType_IntegerParameter* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType_IntegerParameter* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType_IntegerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType_IntegerParameter>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType_IntegerParameter& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType_IntegerParameter& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType_IntegerParameter* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType.IntegerParameter";
+  }
+  protected:
+  explicit ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kRangeStartInclusiveFieldNumber = 2,
+    kRangeEndExclusiveFieldNumber = 3,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2;
+  bool has_range_start_inclusive() const;
+  private:
+  bool _internal_has_range_start_inclusive() const;
+  public:
+  void clear_range_start_inclusive();
+  const ::substrait::ParameterizedType_NullableInteger& range_start_inclusive() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_NullableInteger* release_range_start_inclusive();
+  ::substrait::ParameterizedType_NullableInteger* mutable_range_start_inclusive();
+  void set_allocated_range_start_inclusive(::substrait::ParameterizedType_NullableInteger* range_start_inclusive);
+  private:
+  const ::substrait::ParameterizedType_NullableInteger& _internal_range_start_inclusive() const;
+  ::substrait::ParameterizedType_NullableInteger* _internal_mutable_range_start_inclusive();
+  public:
+  void unsafe_arena_set_allocated_range_start_inclusive(
+      ::substrait::ParameterizedType_NullableInteger* range_start_inclusive);
+  ::substrait::ParameterizedType_NullableInteger* unsafe_arena_release_range_start_inclusive();
+
+  // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3;
+  bool has_range_end_exclusive() const;
+  private:
+  bool _internal_has_range_end_exclusive() const;
+  public:
+  void clear_range_end_exclusive();
+  const ::substrait::ParameterizedType_NullableInteger& range_end_exclusive() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_NullableInteger* release_range_end_exclusive();
+  ::substrait::ParameterizedType_NullableInteger* mutable_range_end_exclusive();
+  void set_allocated_range_end_exclusive(::substrait::ParameterizedType_NullableInteger* range_end_exclusive);
+  private:
+  const ::substrait::ParameterizedType_NullableInteger& _internal_range_end_exclusive() const;
+  ::substrait::ParameterizedType_NullableInteger* _internal_mutable_range_end_exclusive();
+  public:
+  void unsafe_arena_set_allocated_range_end_exclusive(
+      ::substrait::ParameterizedType_NullableInteger* range_end_exclusive);
+  ::substrait::ParameterizedType_NullableInteger* unsafe_arena_release_range_end_exclusive();
+
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.IntegerParameter)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  ::substrait::ParameterizedType_NullableInteger* range_start_inclusive_;
+  ::substrait::ParameterizedType_NullableInteger* range_end_exclusive_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ParameterizedType_NullableInteger final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.NullableInteger) */ {
+ public:
+  inline ParameterizedType_NullableInteger() : ParameterizedType_NullableInteger(nullptr) {}
+  ~ParameterizedType_NullableInteger() override;
+  explicit constexpr ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType_NullableInteger(const ParameterizedType_NullableInteger& from);
+  ParameterizedType_NullableInteger(ParameterizedType_NullableInteger&& from) noexcept
+    : ParameterizedType_NullableInteger() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType_NullableInteger& operator=(const ParameterizedType_NullableInteger& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType_NullableInteger& operator=(ParameterizedType_NullableInteger&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType_NullableInteger& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ParameterizedType_NullableInteger* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType_NullableInteger*>(
+               &_ParameterizedType_NullableInteger_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(ParameterizedType_NullableInteger& a, ParameterizedType_NullableInteger& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType_NullableInteger* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType_NullableInteger* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType_NullableInteger* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType_NullableInteger>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType_NullableInteger& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType_NullableInteger& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType_NullableInteger* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType.NullableInteger";
+  }
+  protected:
+  explicit ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 1,
+  };
+  // int64 value = 1;
+  void clear_value();
+  int64_t value() const;
+  void set_value(int64_t value);
+  private:
+  int64_t _internal_value() const;
+  void _internal_set_value(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.NullableInteger)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int64_t value_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ParameterizedType_ParameterizedFixedChar final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedFixedChar) */ {
+ public:
+  inline ParameterizedType_ParameterizedFixedChar() : ParameterizedType_ParameterizedFixedChar(nullptr) {}
+  ~ParameterizedType_ParameterizedFixedChar() override;
+  explicit constexpr ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType_ParameterizedFixedChar(const ParameterizedType_ParameterizedFixedChar& from);
+  ParameterizedType_ParameterizedFixedChar(ParameterizedType_ParameterizedFixedChar&& from) noexcept
+    : ParameterizedType_ParameterizedFixedChar() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType_ParameterizedFixedChar& operator=(const ParameterizedType_ParameterizedFixedChar& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType_ParameterizedFixedChar& operator=(ParameterizedType_ParameterizedFixedChar&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType_ParameterizedFixedChar& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ParameterizedType_ParameterizedFixedChar* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType_ParameterizedFixedChar*>(
+               &_ParameterizedType_ParameterizedFixedChar_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ParameterizedType_ParameterizedFixedChar& a, ParameterizedType_ParameterizedFixedChar& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType_ParameterizedFixedChar* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType_ParameterizedFixedChar* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType_ParameterizedFixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType_ParameterizedFixedChar>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType_ParameterizedFixedChar& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType_ParameterizedFixedChar& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType_ParameterizedFixedChar* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType.ParameterizedFixedChar";
+  }
+  protected:
+  explicit ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLengthFieldNumber = 1,
+    kVariationPointerFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // .substrait.ParameterizedType.IntegerOption length = 1;
+  bool has_length() const;
+  private:
+  bool _internal_has_length() const;
+  public:
+  void clear_length();
+  const ::substrait::ParameterizedType_IntegerOption& length() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_length();
+  ::substrait::ParameterizedType_IntegerOption* mutable_length();
+  void set_allocated_length(::substrait::ParameterizedType_IntegerOption* length);
+  private:
+  const ::substrait::ParameterizedType_IntegerOption& _internal_length() const;
+  ::substrait::ParameterizedType_IntegerOption* _internal_mutable_length();
+  public:
+  void unsafe_arena_set_allocated_length(
+      ::substrait::ParameterizedType_IntegerOption* length);
+  ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length();
+
+  // uint32 variation_pointer = 2;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedFixedChar)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::ParameterizedType_IntegerOption* length_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ParameterizedType_ParameterizedVarChar final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedVarChar) */ {
+ public:
+  inline ParameterizedType_ParameterizedVarChar() : ParameterizedType_ParameterizedVarChar(nullptr) {}
+  ~ParameterizedType_ParameterizedVarChar() override;
+  explicit constexpr ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType_ParameterizedVarChar(const ParameterizedType_ParameterizedVarChar& from);
+  ParameterizedType_ParameterizedVarChar(ParameterizedType_ParameterizedVarChar&& from) noexcept
+    : ParameterizedType_ParameterizedVarChar() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType_ParameterizedVarChar& operator=(const ParameterizedType_ParameterizedVarChar& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType_ParameterizedVarChar& operator=(ParameterizedType_ParameterizedVarChar&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType_ParameterizedVarChar& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ParameterizedType_ParameterizedVarChar* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType_ParameterizedVarChar*>(
+               &_ParameterizedType_ParameterizedVarChar_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ParameterizedType_ParameterizedVarChar& a, ParameterizedType_ParameterizedVarChar& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType_ParameterizedVarChar* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType_ParameterizedVarChar* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType_ParameterizedVarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType_ParameterizedVarChar>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType_ParameterizedVarChar& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType_ParameterizedVarChar& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType_ParameterizedVarChar* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType.ParameterizedVarChar";
+  }
+  protected:
+  explicit ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLengthFieldNumber = 1,
+    kVariationPointerFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // .substrait.ParameterizedType.IntegerOption length = 1;
+  bool has_length() const;
+  private:
+  bool _internal_has_length() const;
+  public:
+  void clear_length();
+  const ::substrait::ParameterizedType_IntegerOption& length() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_length();
+  ::substrait::ParameterizedType_IntegerOption* mutable_length();
+  void set_allocated_length(::substrait::ParameterizedType_IntegerOption* length);
+  private:
+  const ::substrait::ParameterizedType_IntegerOption& _internal_length() const;
+  ::substrait::ParameterizedType_IntegerOption* _internal_mutable_length();
+  public:
+  void unsafe_arena_set_allocated_length(
+      ::substrait::ParameterizedType_IntegerOption* length);
+  ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length();
+
+  // uint32 variation_pointer = 2;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedVarChar)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::ParameterizedType_IntegerOption* length_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ParameterizedType_ParameterizedFixedBinary final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedFixedBinary) */ {
+ public:
+  inline ParameterizedType_ParameterizedFixedBinary() : ParameterizedType_ParameterizedFixedBinary(nullptr) {}
+  ~ParameterizedType_ParameterizedFixedBinary() override;
+  explicit constexpr ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType_ParameterizedFixedBinary(const ParameterizedType_ParameterizedFixedBinary& from);
+  ParameterizedType_ParameterizedFixedBinary(ParameterizedType_ParameterizedFixedBinary&& from) noexcept
+    : ParameterizedType_ParameterizedFixedBinary() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType_ParameterizedFixedBinary& operator=(const ParameterizedType_ParameterizedFixedBinary& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType_ParameterizedFixedBinary& operator=(ParameterizedType_ParameterizedFixedBinary&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType_ParameterizedFixedBinary& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ParameterizedType_ParameterizedFixedBinary* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType_ParameterizedFixedBinary*>(
+               &_ParameterizedType_ParameterizedFixedBinary_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(ParameterizedType_ParameterizedFixedBinary& a, ParameterizedType_ParameterizedFixedBinary& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType_ParameterizedFixedBinary* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType_ParameterizedFixedBinary* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType_ParameterizedFixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType_ParameterizedFixedBinary>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType_ParameterizedFixedBinary& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType_ParameterizedFixedBinary& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType_ParameterizedFixedBinary* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType.ParameterizedFixedBinary";
+  }
+  protected:
+  explicit ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLengthFieldNumber = 1,
+    kVariationPointerFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // .substrait.ParameterizedType.IntegerOption length = 1;
+  bool has_length() const;
+  private:
+  bool _internal_has_length() const;
+  public:
+  void clear_length();
+  const ::substrait::ParameterizedType_IntegerOption& length() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_length();
+  ::substrait::ParameterizedType_IntegerOption* mutable_length();
+  void set_allocated_length(::substrait::ParameterizedType_IntegerOption* length);
+  private:
+  const ::substrait::ParameterizedType_IntegerOption& _internal_length() const;
+  ::substrait::ParameterizedType_IntegerOption* _internal_mutable_length();
+  public:
+  void unsafe_arena_set_allocated_length(
+      ::substrait::ParameterizedType_IntegerOption* length);
+  ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length();
+
+  // uint32 variation_pointer = 2;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedFixedBinary)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::ParameterizedType_IntegerOption* length_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ParameterizedType_ParameterizedDecimal final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedDecimal) */ {
+ public:
+  inline ParameterizedType_ParameterizedDecimal() : ParameterizedType_ParameterizedDecimal(nullptr) {}
+  ~ParameterizedType_ParameterizedDecimal() override;
+  explicit constexpr ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType_ParameterizedDecimal(const ParameterizedType_ParameterizedDecimal& from);
+  ParameterizedType_ParameterizedDecimal(ParameterizedType_ParameterizedDecimal&& from) noexcept
+    : ParameterizedType_ParameterizedDecimal() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType_ParameterizedDecimal& operator=(const ParameterizedType_ParameterizedDecimal& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType_ParameterizedDecimal& operator=(ParameterizedType_ParameterizedDecimal&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType_ParameterizedDecimal& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ParameterizedType_ParameterizedDecimal* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType_ParameterizedDecimal*>(
+               &_ParameterizedType_ParameterizedDecimal_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(ParameterizedType_ParameterizedDecimal& a, ParameterizedType_ParameterizedDecimal& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType_ParameterizedDecimal* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType_ParameterizedDecimal* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType_ParameterizedDecimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType_ParameterizedDecimal>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType_ParameterizedDecimal& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType_ParameterizedDecimal& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType_ParameterizedDecimal* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType.ParameterizedDecimal";
+  }
+  protected:
+  explicit ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kScaleFieldNumber = 1,
+    kPrecisionFieldNumber = 2,
+    kVariationPointerFieldNumber = 3,
+    kNullabilityFieldNumber = 4,
+  };
+  // .substrait.ParameterizedType.IntegerOption scale = 1;
+  bool has_scale() const;
+  private:
+  bool _internal_has_scale() const;
+  public:
+  void clear_scale();
+  const ::substrait::ParameterizedType_IntegerOption& scale() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_scale();
+  ::substrait::ParameterizedType_IntegerOption* mutable_scale();
+  void set_allocated_scale(::substrait::ParameterizedType_IntegerOption* scale);
+  private:
+  const ::substrait::ParameterizedType_IntegerOption& _internal_scale() const;
+  ::substrait::ParameterizedType_IntegerOption* _internal_mutable_scale();
+  public:
+  void unsafe_arena_set_allocated_scale(
+      ::substrait::ParameterizedType_IntegerOption* scale);
+  ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_scale();
+
+  // .substrait.ParameterizedType.IntegerOption precision = 2;
+  bool has_precision() const;
+  private:
+  bool _internal_has_precision() const;
+  public:
+  void clear_precision();
+  const ::substrait::ParameterizedType_IntegerOption& precision() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_precision();
+  ::substrait::ParameterizedType_IntegerOption* mutable_precision();
+  void set_allocated_precision(::substrait::ParameterizedType_IntegerOption* precision);
+  private:
+  const ::substrait::ParameterizedType_IntegerOption& _internal_precision() const;
+  ::substrait::ParameterizedType_IntegerOption* _internal_mutable_precision();
+  public:
+  void unsafe_arena_set_allocated_precision(
+      ::substrait::ParameterizedType_IntegerOption* precision);
+  ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_precision();
+
+  // uint32 variation_pointer = 3;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 4;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedDecimal)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::ParameterizedType_IntegerOption* scale_;
+  ::substrait::ParameterizedType_IntegerOption* precision_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ParameterizedType_ParameterizedStruct final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedStruct) */ {
+ public:
+  inline ParameterizedType_ParameterizedStruct() : ParameterizedType_ParameterizedStruct(nullptr) {}
+  ~ParameterizedType_ParameterizedStruct() override;
+  explicit constexpr ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType_ParameterizedStruct(const ParameterizedType_ParameterizedStruct& from);
+  ParameterizedType_ParameterizedStruct(ParameterizedType_ParameterizedStruct&& from) noexcept
+    : ParameterizedType_ParameterizedStruct() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType_ParameterizedStruct& operator=(const ParameterizedType_ParameterizedStruct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType_ParameterizedStruct& operator=(ParameterizedType_ParameterizedStruct&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType_ParameterizedStruct& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ParameterizedType_ParameterizedStruct* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType_ParameterizedStruct*>(
+               &_ParameterizedType_ParameterizedStruct_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(ParameterizedType_ParameterizedStruct& a, ParameterizedType_ParameterizedStruct& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType_ParameterizedStruct* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType_ParameterizedStruct* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType_ParameterizedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType_ParameterizedStruct>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType_ParameterizedStruct& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType_ParameterizedStruct& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType_ParameterizedStruct* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType.ParameterizedStruct";
+  }
+  protected:
+  explicit ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypesFieldNumber = 1,
+    kVariationPointerFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // repeated .substrait.ParameterizedType types = 1;
+  int types_size() const;
+  private:
+  int _internal_types_size() const;
+  public:
+  void clear_types();
+  ::substrait::ParameterizedType* mutable_types(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >*
+      mutable_types();
+  private:
+  const ::substrait::ParameterizedType& _internal_types(int index) const;
+  ::substrait::ParameterizedType* _internal_add_types();
+  public:
+  const ::substrait::ParameterizedType& types(int index) const;
+  ::substrait::ParameterizedType* add_types();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >&
+      types() const;
+
+  // uint32 variation_pointer = 2;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedStruct)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType > types_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ParameterizedType_ParameterizedNamedStruct final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedNamedStruct) */ {
+ public:
+  inline ParameterizedType_ParameterizedNamedStruct() : ParameterizedType_ParameterizedNamedStruct(nullptr) {}
+  ~ParameterizedType_ParameterizedNamedStruct() override;
+  explicit constexpr ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType_ParameterizedNamedStruct(const ParameterizedType_ParameterizedNamedStruct& from);
+  ParameterizedType_ParameterizedNamedStruct(ParameterizedType_ParameterizedNamedStruct&& from) noexcept
+    : ParameterizedType_ParameterizedNamedStruct() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType_ParameterizedNamedStruct& operator=(const ParameterizedType_ParameterizedNamedStruct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType_ParameterizedNamedStruct& operator=(ParameterizedType_ParameterizedNamedStruct&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType_ParameterizedNamedStruct& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ParameterizedType_ParameterizedNamedStruct* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType_ParameterizedNamedStruct*>(
+               &_ParameterizedType_ParameterizedNamedStruct_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(ParameterizedType_ParameterizedNamedStruct& a, ParameterizedType_ParameterizedNamedStruct& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType_ParameterizedNamedStruct* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType_ParameterizedNamedStruct* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType_ParameterizedNamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType_ParameterizedNamedStruct>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType_ParameterizedNamedStruct& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType_ParameterizedNamedStruct& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType_ParameterizedNamedStruct* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType.ParameterizedNamedStruct";
+  }
+  protected:
+  explicit ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNamesFieldNumber = 1,
+    kStructFieldNumber = 2,
+  };
+  // repeated string names = 1;
+  int names_size() const;
+  private:
+  int _internal_names_size() const;
+  public:
+  void clear_names();
+  const std::string& names(int index) const;
+  std::string* mutable_names(int index);
+  void set_names(int index, const std::string& value);
+  void set_names(int index, std::string&& value);
+  void set_names(int index, const char* value);
+  void set_names(int index, const char* value, size_t size);
+  std::string* add_names();
+  void add_names(const std::string& value);
+  void add_names(std::string&& value);
+  void add_names(const char* value);
+  void add_names(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& names() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_names();
+  private:
+  const std::string& _internal_names(int index) const;
+  std::string* _internal_add_names();
+  public:
+
+  // .substrait.ParameterizedType.ParameterizedStruct struct = 2;
+  bool has_struct_() const;
+  private:
+  bool _internal_has_struct_() const;
+  public:
+  void clear_struct_();
+  const ::substrait::ParameterizedType_ParameterizedStruct& struct_() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedStruct* release_struct_();
+  ::substrait::ParameterizedType_ParameterizedStruct* mutable_struct_();
+  void set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_);
+  private:
+  const ::substrait::ParameterizedType_ParameterizedStruct& _internal_struct_() const;
+  ::substrait::ParameterizedType_ParameterizedStruct* _internal_mutable_struct_();
+  public:
+  void unsafe_arena_set_allocated_struct_(
+      ::substrait::ParameterizedType_ParameterizedStruct* struct_);
+  ::substrait::ParameterizedType_ParameterizedStruct* unsafe_arena_release_struct_();
+
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedNamedStruct)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> names_;
+  ::substrait::ParameterizedType_ParameterizedStruct* struct__;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ParameterizedType_ParameterizedList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedList) */ {
+ public:
+  inline ParameterizedType_ParameterizedList() : ParameterizedType_ParameterizedList(nullptr) {}
+  ~ParameterizedType_ParameterizedList() override;
+  explicit constexpr ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType_ParameterizedList(const ParameterizedType_ParameterizedList& from);
+  ParameterizedType_ParameterizedList(ParameterizedType_ParameterizedList&& from) noexcept
+    : ParameterizedType_ParameterizedList() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType_ParameterizedList& operator=(const ParameterizedType_ParameterizedList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType_ParameterizedList& operator=(ParameterizedType_ParameterizedList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType_ParameterizedList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ParameterizedType_ParameterizedList* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType_ParameterizedList*>(
+               &_ParameterizedType_ParameterizedList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(ParameterizedType_ParameterizedList& a, ParameterizedType_ParameterizedList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType_ParameterizedList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType_ParameterizedList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType_ParameterizedList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType_ParameterizedList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType_ParameterizedList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType_ParameterizedList& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType_ParameterizedList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType.ParameterizedList";
+  }
+  protected:
+  explicit ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeFieldNumber = 1,
+    kVariationPointerFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // .substrait.ParameterizedType type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  const ::substrait::ParameterizedType& type() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_type();
+  ::substrait::ParameterizedType* mutable_type();
+  void set_allocated_type(::substrait::ParameterizedType* type);
+  private:
+  const ::substrait::ParameterizedType& _internal_type() const;
+  ::substrait::ParameterizedType* _internal_mutable_type();
+  public:
+  void unsafe_arena_set_allocated_type(
+      ::substrait::ParameterizedType* type);
+  ::substrait::ParameterizedType* unsafe_arena_release_type();
+
+  // uint32 variation_pointer = 2;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::ParameterizedType* type_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ParameterizedType_ParameterizedMap final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedMap) */ {
+ public:
+  inline ParameterizedType_ParameterizedMap() : ParameterizedType_ParameterizedMap(nullptr) {}
+  ~ParameterizedType_ParameterizedMap() override;
+  explicit constexpr ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType_ParameterizedMap(const ParameterizedType_ParameterizedMap& from);
+  ParameterizedType_ParameterizedMap(ParameterizedType_ParameterizedMap&& from) noexcept
+    : ParameterizedType_ParameterizedMap() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType_ParameterizedMap& operator=(const ParameterizedType_ParameterizedMap& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType_ParameterizedMap& operator=(ParameterizedType_ParameterizedMap&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType_ParameterizedMap& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ParameterizedType_ParameterizedMap* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType_ParameterizedMap*>(
+               &_ParameterizedType_ParameterizedMap_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(ParameterizedType_ParameterizedMap& a, ParameterizedType_ParameterizedMap& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType_ParameterizedMap* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType_ParameterizedMap* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType_ParameterizedMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType_ParameterizedMap>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType_ParameterizedMap& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType_ParameterizedMap& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType_ParameterizedMap* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType.ParameterizedMap";
+  }
+  protected:
+  explicit ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+    kVariationPointerFieldNumber = 3,
+    kNullabilityFieldNumber = 4,
+  };
+  // .substrait.ParameterizedType key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::substrait::ParameterizedType& key() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_key();
+  ::substrait::ParameterizedType* mutable_key();
+  void set_allocated_key(::substrait::ParameterizedType* key);
+  private:
+  const ::substrait::ParameterizedType& _internal_key() const;
+  ::substrait::ParameterizedType* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::substrait::ParameterizedType* key);
+  ::substrait::ParameterizedType* unsafe_arena_release_key();
+
+  // .substrait.ParameterizedType value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const ::substrait::ParameterizedType& value() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_value();
+  ::substrait::ParameterizedType* mutable_value();
+  void set_allocated_value(::substrait::ParameterizedType* value);
+  private:
+  const ::substrait::ParameterizedType& _internal_value() const;
+  ::substrait::ParameterizedType* _internal_mutable_value();
+  public:
+  void unsafe_arena_set_allocated_value(
+      ::substrait::ParameterizedType* value);
+  ::substrait::ParameterizedType* unsafe_arena_release_value();
+
+  // uint32 variation_pointer = 3;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 4;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedMap)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::ParameterizedType* key_;
+  ::substrait::ParameterizedType* value_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ParameterizedType_IntegerOption final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.IntegerOption) */ {
+ public:
+  inline ParameterizedType_IntegerOption() : ParameterizedType_IntegerOption(nullptr) {}
+  ~ParameterizedType_IntegerOption() override;
+  explicit constexpr ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType_IntegerOption(const ParameterizedType_IntegerOption& from);
+  ParameterizedType_IntegerOption(ParameterizedType_IntegerOption&& from) noexcept
+    : ParameterizedType_IntegerOption() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType_IntegerOption& operator=(const ParameterizedType_IntegerOption& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType_IntegerOption& operator=(ParameterizedType_IntegerOption&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType_IntegerOption& default_instance() {
+    return *internal_default_instance();
+  }
+  enum IntegerTypeCase {
+    kLiteral = 1,
+    kParameter = 2,
+    INTEGER_TYPE_NOT_SET = 0,
+  };
+
+  static inline const ParameterizedType_IntegerOption* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType_IntegerOption*>(
+               &_ParameterizedType_IntegerOption_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(ParameterizedType_IntegerOption& a, ParameterizedType_IntegerOption& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType_IntegerOption* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType_IntegerOption* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType_IntegerOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType_IntegerOption>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType_IntegerOption& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType_IntegerOption& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType_IntegerOption* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType.IntegerOption";
+  }
+  protected:
+  explicit ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLiteralFieldNumber = 1,
+    kParameterFieldNumber = 2,
+  };
+  // int32 literal = 1;
+  bool has_literal() const;
+  private:
+  bool _internal_has_literal() const;
+  public:
+  void clear_literal();
+  int32_t literal() const;
+  void set_literal(int32_t value);
+  private:
+  int32_t _internal_literal() const;
+  void _internal_set_literal(int32_t value);
+  public:
+
+  // .substrait.ParameterizedType.IntegerParameter parameter = 2;
+  bool has_parameter() const;
+  private:
+  bool _internal_has_parameter() const;
+  public:
+  void clear_parameter();
+  const ::substrait::ParameterizedType_IntegerParameter& parameter() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerParameter* release_parameter();
+  ::substrait::ParameterizedType_IntegerParameter* mutable_parameter();
+  void set_allocated_parameter(::substrait::ParameterizedType_IntegerParameter* parameter);
+  private:
+  const ::substrait::ParameterizedType_IntegerParameter& _internal_parameter() const;
+  ::substrait::ParameterizedType_IntegerParameter* _internal_mutable_parameter();
+  public:
+  void unsafe_arena_set_allocated_parameter(
+      ::substrait::ParameterizedType_IntegerParameter* parameter);
+  ::substrait::ParameterizedType_IntegerParameter* unsafe_arena_release_parameter();
+
+  void clear_integer_type();
+  IntegerTypeCase integer_type_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.IntegerOption)
+ private:
+  class _Internal;
+  void set_has_literal();
+  void set_has_parameter();
+
+  inline bool has_integer_type() const;
+  inline void clear_has_integer_type();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union IntegerTypeUnion {
+    constexpr IntegerTypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    int32_t literal_;
+    ::substrait::ParameterizedType_IntegerParameter* parameter_;
+  } integer_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ParameterizedType final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType) */ {
+ public:
+  inline ParameterizedType() : ParameterizedType(nullptr) {}
+  ~ParameterizedType() override;
+  explicit constexpr ParameterizedType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ParameterizedType(const ParameterizedType& from);
+  ParameterizedType(ParameterizedType&& from) noexcept
+    : ParameterizedType() {
+    *this = ::std::move(from);
+  }
+
+  inline ParameterizedType& operator=(const ParameterizedType& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ParameterizedType& operator=(ParameterizedType&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ParameterizedType& default_instance() {
+    return *internal_default_instance();
+  }
+  enum KindCase {
+    kBool = 1,
+    kI8 = 2,
+    kI16 = 3,
+    kI32 = 5,
+    kI64 = 7,
+    kFp32 = 10,
+    kFp64 = 11,
+    kString = 12,
+    kBinary = 13,
+    kTimestamp = 14,
+    kDate = 16,
+    kTime = 17,
+    kIntervalYear = 19,
+    kIntervalDay = 20,
+    kTimestampTz = 29,
+    kUuid = 32,
+    kFixedChar = 21,
+    kVarchar = 22,
+    kFixedBinary = 23,
+    kDecimal = 24,
+    kStruct = 25,
+    kList = 27,
+    kMap = 28,
+    kUserDefinedPointer = 31,
+    kTypeParameter = 33,
+    KIND_NOT_SET = 0,
+  };
+
+  static inline const ParameterizedType* internal_default_instance() {
+    return reinterpret_cast<const ParameterizedType*>(
+               &_ParameterizedType_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(ParameterizedType& a, ParameterizedType& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ParameterizedType* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ParameterizedType* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ParameterizedType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ParameterizedType>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ParameterizedType& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ParameterizedType& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ParameterizedType* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ParameterizedType";
+  }
+  protected:
+  explicit ParameterizedType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ParameterizedType_TypeParameter TypeParameter;
+  typedef ParameterizedType_IntegerParameter IntegerParameter;
+  typedef ParameterizedType_NullableInteger NullableInteger;
+  typedef ParameterizedType_ParameterizedFixedChar ParameterizedFixedChar;
+  typedef ParameterizedType_ParameterizedVarChar ParameterizedVarChar;
+  typedef ParameterizedType_ParameterizedFixedBinary ParameterizedFixedBinary;
+  typedef ParameterizedType_ParameterizedDecimal ParameterizedDecimal;
+  typedef ParameterizedType_ParameterizedStruct ParameterizedStruct;
+  typedef ParameterizedType_ParameterizedNamedStruct ParameterizedNamedStruct;
+  typedef ParameterizedType_ParameterizedList ParameterizedList;
+  typedef ParameterizedType_ParameterizedMap ParameterizedMap;
+  typedef ParameterizedType_IntegerOption IntegerOption;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBoolFieldNumber = 1,
+    kI8FieldNumber = 2,
+    kI16FieldNumber = 3,
+    kI32FieldNumber = 5,
+    kI64FieldNumber = 7,
+    kFp32FieldNumber = 10,
+    kFp64FieldNumber = 11,
+    kStringFieldNumber = 12,
+    kBinaryFieldNumber = 13,
+    kTimestampFieldNumber = 14,
+    kDateFieldNumber = 16,
+    kTimeFieldNumber = 17,
+    kIntervalYearFieldNumber = 19,
+    kIntervalDayFieldNumber = 20,
+    kTimestampTzFieldNumber = 29,
+    kUuidFieldNumber = 32,
+    kFixedCharFieldNumber = 21,
+    kVarcharFieldNumber = 22,
+    kFixedBinaryFieldNumber = 23,
+    kDecimalFieldNumber = 24,
+    kStructFieldNumber = 25,
+    kListFieldNumber = 27,
+    kMapFieldNumber = 28,
+    kUserDefinedPointerFieldNumber = 31,
+    kTypeParameterFieldNumber = 33,
+  };
+  // .substrait.Type.Boolean bool = 1;
+  bool has_bool_() const;
+  private:
+  bool _internal_has_bool_() const;
+  public:
+  void clear_bool_();
+  const ::substrait::Type_Boolean& bool_() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Boolean* release_bool_();
+  ::substrait::Type_Boolean* mutable_bool_();
+  void set_allocated_bool_(::substrait::Type_Boolean* bool_);
+  private:
+  const ::substrait::Type_Boolean& _internal_bool_() const;
+  ::substrait::Type_Boolean* _internal_mutable_bool_();
+  public:
+  void unsafe_arena_set_allocated_bool_(
+      ::substrait::Type_Boolean* bool_);
+  ::substrait::Type_Boolean* unsafe_arena_release_bool_();
+
+  // .substrait.Type.I8 i8 = 2;
+  bool has_i8() const;
+  private:
+  bool _internal_has_i8() const;
+  public:
+  void clear_i8();
+  const ::substrait::Type_I8& i8() const;
+  PROTOBUF_NODISCARD ::substrait::Type_I8* release_i8();
+  ::substrait::Type_I8* mutable_i8();
+  void set_allocated_i8(::substrait::Type_I8* i8);
+  private:
+  const ::substrait::Type_I8& _internal_i8() const;
+  ::substrait::Type_I8* _internal_mutable_i8();
+  public:
+  void unsafe_arena_set_allocated_i8(
+      ::substrait::Type_I8* i8);
+  ::substrait::Type_I8* unsafe_arena_release_i8();
+
+  // .substrait.Type.I16 i16 = 3;
+  bool has_i16() const;
+  private:
+  bool _internal_has_i16() const;
+  public:
+  void clear_i16();
+  const ::substrait::Type_I16& i16() const;
+  PROTOBUF_NODISCARD ::substrait::Type_I16* release_i16();
+  ::substrait::Type_I16* mutable_i16();
+  void set_allocated_i16(::substrait::Type_I16* i16);
+  private:
+  const ::substrait::Type_I16& _internal_i16() const;
+  ::substrait::Type_I16* _internal_mutable_i16();
+  public:
+  void unsafe_arena_set_allocated_i16(
+      ::substrait::Type_I16* i16);
+  ::substrait::Type_I16* unsafe_arena_release_i16();
+
+  // .substrait.Type.I32 i32 = 5;
+  bool has_i32() const;
+  private:
+  bool _internal_has_i32() const;
+  public:
+  void clear_i32();
+  const ::substrait::Type_I32& i32() const;
+  PROTOBUF_NODISCARD ::substrait::Type_I32* release_i32();
+  ::substrait::Type_I32* mutable_i32();
+  void set_allocated_i32(::substrait::Type_I32* i32);
+  private:
+  const ::substrait::Type_I32& _internal_i32() const;
+  ::substrait::Type_I32* _internal_mutable_i32();
+  public:
+  void unsafe_arena_set_allocated_i32(
+      ::substrait::Type_I32* i32);
+  ::substrait::Type_I32* unsafe_arena_release_i32();
+
+  // .substrait.Type.I64 i64 = 7;
+  bool has_i64() const;
+  private:
+  bool _internal_has_i64() const;
+  public:
+  void clear_i64();
+  const ::substrait::Type_I64& i64() const;
+  PROTOBUF_NODISCARD ::substrait::Type_I64* release_i64();
+  ::substrait::Type_I64* mutable_i64();
+  void set_allocated_i64(::substrait::Type_I64* i64);
+  private:
+  const ::substrait::Type_I64& _internal_i64() const;
+  ::substrait::Type_I64* _internal_mutable_i64();
+  public:
+  void unsafe_arena_set_allocated_i64(
+      ::substrait::Type_I64* i64);
+  ::substrait::Type_I64* unsafe_arena_release_i64();
+
+  // .substrait.Type.FP32 fp32 = 10;
+  bool has_fp32() const;
+  private:
+  bool _internal_has_fp32() const;
+  public:
+  void clear_fp32();
+  const ::substrait::Type_FP32& fp32() const;
+  PROTOBUF_NODISCARD ::substrait::Type_FP32* release_fp32();
+  ::substrait::Type_FP32* mutable_fp32();
+  void set_allocated_fp32(::substrait::Type_FP32* fp32);
+  private:
+  const ::substrait::Type_FP32& _internal_fp32() const;
+  ::substrait::Type_FP32* _internal_mutable_fp32();
+  public:
+  void unsafe_arena_set_allocated_fp32(
+      ::substrait::Type_FP32* fp32);
+  ::substrait::Type_FP32* unsafe_arena_release_fp32();
+
+  // .substrait.Type.FP64 fp64 = 11;
+  bool has_fp64() const;
+  private:
+  bool _internal_has_fp64() const;
+  public:
+  void clear_fp64();
+  const ::substrait::Type_FP64& fp64() const;
+  PROTOBUF_NODISCARD ::substrait::Type_FP64* release_fp64();
+  ::substrait::Type_FP64* mutable_fp64();
+  void set_allocated_fp64(::substrait::Type_FP64* fp64);
+  private:
+  const ::substrait::Type_FP64& _internal_fp64() const;
+  ::substrait::Type_FP64* _internal_mutable_fp64();
+  public:
+  void unsafe_arena_set_allocated_fp64(
+      ::substrait::Type_FP64* fp64);
+  ::substrait::Type_FP64* unsafe_arena_release_fp64();
+
+  // .substrait.Type.String string = 12;
+  bool has_string() const;
+  private:
+  bool _internal_has_string() const;
+  public:
+  void clear_string();
+  const ::substrait::Type_String& string() const;
+  PROTOBUF_NODISCARD ::substrait::Type_String* release_string();
+  ::substrait::Type_String* mutable_string();
+  void set_allocated_string(::substrait::Type_String* string);
+  private:
+  const ::substrait::Type_String& _internal_string() const;
+  ::substrait::Type_String* _internal_mutable_string();
+  public:
+  void unsafe_arena_set_allocated_string(
+      ::substrait::Type_String* string);
+  ::substrait::Type_String* unsafe_arena_release_string();
+
+  // .substrait.Type.Binary binary = 13;
+  bool has_binary() const;
+  private:
+  bool _internal_has_binary() const;
+  public:
+  void clear_binary();
+  const ::substrait::Type_Binary& binary() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Binary* release_binary();
+  ::substrait::Type_Binary* mutable_binary();
+  void set_allocated_binary(::substrait::Type_Binary* binary);
+  private:
+  const ::substrait::Type_Binary& _internal_binary() const;
+  ::substrait::Type_Binary* _internal_mutable_binary();
+  public:
+  void unsafe_arena_set_allocated_binary(
+      ::substrait::Type_Binary* binary);
+  ::substrait::Type_Binary* unsafe_arena_release_binary();
+
+  // .substrait.Type.Timestamp timestamp = 14;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  const ::substrait::Type_Timestamp& timestamp() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Timestamp* release_timestamp();
+  ::substrait::Type_Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp);
+  private:
+  const ::substrait::Type_Timestamp& _internal_timestamp() const;
+  ::substrait::Type_Timestamp* _internal_mutable_timestamp();
+  public:
+  void unsafe_arena_set_allocated_timestamp(
+      ::substrait::Type_Timestamp* timestamp);
+  ::substrait::Type_Timestamp* unsafe_arena_release_timestamp();
+
+  // .substrait.Type.Date date = 16;
+  bool has_date() const;
+  private:
+  bool _internal_has_date() const;
+  public:
+  void clear_date();
+  const ::substrait::Type_Date& date() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Date* release_date();
+  ::substrait::Type_Date* mutable_date();
+  void set_allocated_date(::substrait::Type_Date* date);
+  private:
+  const ::substrait::Type_Date& _internal_date() const;
+  ::substrait::Type_Date* _internal_mutable_date();
+  public:
+  void unsafe_arena_set_allocated_date(
+      ::substrait::Type_Date* date);
+  ::substrait::Type_Date* unsafe_arena_release_date();
+
+  // .substrait.Type.Time time = 17;
+  bool has_time() const;
+  private:
+  bool _internal_has_time() const;
+  public:
+  void clear_time();
+  const ::substrait::Type_Time& time() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Time* release_time();
+  ::substrait::Type_Time* mutable_time();
+  void set_allocated_time(::substrait::Type_Time* time);
+  private:
+  const ::substrait::Type_Time& _internal_time() const;
+  ::substrait::Type_Time* _internal_mutable_time();
+  public:
+  void unsafe_arena_set_allocated_time(
+      ::substrait::Type_Time* time);
+  ::substrait::Type_Time* unsafe_arena_release_time();
+
+  // .substrait.Type.IntervalYear interval_year = 19;
+  bool has_interval_year() const;
+  private:
+  bool _internal_has_interval_year() const;
+  public:
+  void clear_interval_year();
+  const ::substrait::Type_IntervalYear& interval_year() const;
+  PROTOBUF_NODISCARD ::substrait::Type_IntervalYear* release_interval_year();
+  ::substrait::Type_IntervalYear* mutable_interval_year();
+  void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year);
+  private:
+  const ::substrait::Type_IntervalYear& _internal_interval_year() const;
+  ::substrait::Type_IntervalYear* _internal_mutable_interval_year();
+  public:
+  void unsafe_arena_set_allocated_interval_year(
+      ::substrait::Type_IntervalYear* interval_year);
+  ::substrait::Type_IntervalYear* unsafe_arena_release_interval_year();
+
+  // .substrait.Type.IntervalDay interval_day = 20;
+  bool has_interval_day() const;
+  private:
+  bool _internal_has_interval_day() const;
+  public:
+  void clear_interval_day();
+  const ::substrait::Type_IntervalDay& interval_day() const;
+  PROTOBUF_NODISCARD ::substrait::Type_IntervalDay* release_interval_day();
+  ::substrait::Type_IntervalDay* mutable_interval_day();
+  void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day);
+  private:
+  const ::substrait::Type_IntervalDay& _internal_interval_day() const;
+  ::substrait::Type_IntervalDay* _internal_mutable_interval_day();
+  public:
+  void unsafe_arena_set_allocated_interval_day(
+      ::substrait::Type_IntervalDay* interval_day);
+  ::substrait::Type_IntervalDay* unsafe_arena_release_interval_day();
+
+  // .substrait.Type.TimestampTZ timestamp_tz = 29;
+  bool has_timestamp_tz() const;
+  private:
+  bool _internal_has_timestamp_tz() const;
+  public:
+  void clear_timestamp_tz();
+  const ::substrait::Type_TimestampTZ& timestamp_tz() const;
+  PROTOBUF_NODISCARD ::substrait::Type_TimestampTZ* release_timestamp_tz();
+  ::substrait::Type_TimestampTZ* mutable_timestamp_tz();
+  void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz);
+  private:
+  const ::substrait::Type_TimestampTZ& _internal_timestamp_tz() const;
+  ::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz();
+  public:
+  void unsafe_arena_set_allocated_timestamp_tz(
+      ::substrait::Type_TimestampTZ* timestamp_tz);
+  ::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz();
+
+  // .substrait.Type.UUID uuid = 32;
+  bool has_uuid() const;
+  private:
+  bool _internal_has_uuid() const;
+  public:
+  void clear_uuid();
+  const ::substrait::Type_UUID& uuid() const;
+  PROTOBUF_NODISCARD ::substrait::Type_UUID* release_uuid();
+  ::substrait::Type_UUID* mutable_uuid();
+  void set_allocated_uuid(::substrait::Type_UUID* uuid);
+  private:
+  const ::substrait::Type_UUID& _internal_uuid() const;
+  ::substrait::Type_UUID* _internal_mutable_uuid();
+  public:
+  void unsafe_arena_set_allocated_uuid(
+      ::substrait::Type_UUID* uuid);
+  ::substrait::Type_UUID* unsafe_arena_release_uuid();
+
+  // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21;
+  bool has_fixed_char() const;
+  private:
+  bool _internal_has_fixed_char() const;
+  public:
+  void clear_fixed_char();
+  const ::substrait::ParameterizedType_ParameterizedFixedChar& fixed_char() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedFixedChar* release_fixed_char();
+  ::substrait::ParameterizedType_ParameterizedFixedChar* mutable_fixed_char();
+  void set_allocated_fixed_char(::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char);
+  private:
+  const ::substrait::ParameterizedType_ParameterizedFixedChar& _internal_fixed_char() const;
+  ::substrait::ParameterizedType_ParameterizedFixedChar* _internal_mutable_fixed_char();
+  public:
+  void unsafe_arena_set_allocated_fixed_char(
+      ::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char);
+  ::substrait::ParameterizedType_ParameterizedFixedChar* unsafe_arena_release_fixed_char();
+
+  // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22;
+  bool has_varchar() const;
+  private:
+  bool _internal_has_varchar() const;
+  public:
+  void clear_varchar();
+  const ::substrait::ParameterizedType_ParameterizedVarChar& varchar() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedVarChar* release_varchar();
+  ::substrait::ParameterizedType_ParameterizedVarChar* mutable_varchar();
+  void set_allocated_varchar(::substrait::ParameterizedType_ParameterizedVarChar* varchar);
+  private:
+  const ::substrait::ParameterizedType_ParameterizedVarChar& _internal_varchar() const;
+  ::substrait::ParameterizedType_ParameterizedVarChar* _internal_mutable_varchar();
+  public:
+  void unsafe_arena_set_allocated_varchar(
+      ::substrait::ParameterizedType_ParameterizedVarChar* varchar);
+  ::substrait::ParameterizedType_ParameterizedVarChar* unsafe_arena_release_varchar();
+
+  // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23;
+  bool has_fixed_binary() const;
+  private:
+  bool _internal_has_fixed_binary() const;
+  public:
+  void clear_fixed_binary();
+  const ::substrait::ParameterizedType_ParameterizedFixedBinary& fixed_binary() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedFixedBinary* release_fixed_binary();
+  ::substrait::ParameterizedType_ParameterizedFixedBinary* mutable_fixed_binary();
+  void set_allocated_fixed_binary(::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary);
+  private:
+  const ::substrait::ParameterizedType_ParameterizedFixedBinary& _internal_fixed_binary() const;
+  ::substrait::ParameterizedType_ParameterizedFixedBinary* _internal_mutable_fixed_binary();
+  public:
+  void unsafe_arena_set_allocated_fixed_binary(
+      ::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary);
+  ::substrait::ParameterizedType_ParameterizedFixedBinary* unsafe_arena_release_fixed_binary();
+
+  // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24;
+  bool has_decimal() const;
+  private:
+  bool _internal_has_decimal() const;
+  public:
+  void clear_decimal();
+  const ::substrait::ParameterizedType_ParameterizedDecimal& decimal() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedDecimal* release_decimal();
+  ::substrait::ParameterizedType_ParameterizedDecimal* mutable_decimal();
+  void set_allocated_decimal(::substrait::ParameterizedType_ParameterizedDecimal* decimal);
+  private:
+  const ::substrait::ParameterizedType_ParameterizedDecimal& _internal_decimal() const;
+  ::substrait::ParameterizedType_ParameterizedDecimal* _internal_mutable_decimal();
+  public:
+  void unsafe_arena_set_allocated_decimal(
+      ::substrait::ParameterizedType_ParameterizedDecimal* decimal);
+  ::substrait::ParameterizedType_ParameterizedDecimal* unsafe_arena_release_decimal();
+
+  // .substrait.ParameterizedType.ParameterizedStruct struct = 25;
+  bool has_struct_() const;
+  private:
+  bool _internal_has_struct_() const;
+  public:
+  void clear_struct_();
+  const ::substrait::ParameterizedType_ParameterizedStruct& struct_() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedStruct* release_struct_();
+  ::substrait::ParameterizedType_ParameterizedStruct* mutable_struct_();
+  void set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_);
+  private:
+  const ::substrait::ParameterizedType_ParameterizedStruct& _internal_struct_() const;
+  ::substrait::ParameterizedType_ParameterizedStruct* _internal_mutable_struct_();
+  public:
+  void unsafe_arena_set_allocated_struct_(
+      ::substrait::ParameterizedType_ParameterizedStruct* struct_);
+  ::substrait::ParameterizedType_ParameterizedStruct* unsafe_arena_release_struct_();
+
+  // .substrait.ParameterizedType.ParameterizedList list = 27;
+  bool has_list() const;
+  private:
+  bool _internal_has_list() const;
+  public:
+  void clear_list();
+  const ::substrait::ParameterizedType_ParameterizedList& list() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedList* release_list();
+  ::substrait::ParameterizedType_ParameterizedList* mutable_list();
+  void set_allocated_list(::substrait::ParameterizedType_ParameterizedList* list);
+  private:
+  const ::substrait::ParameterizedType_ParameterizedList& _internal_list() const;
+  ::substrait::ParameterizedType_ParameterizedList* _internal_mutable_list();
+  public:
+  void unsafe_arena_set_allocated_list(
+      ::substrait::ParameterizedType_ParameterizedList* list);
+  ::substrait::ParameterizedType_ParameterizedList* unsafe_arena_release_list();
+
+  // .substrait.ParameterizedType.ParameterizedMap map = 28;
+  bool has_map() const;
+  private:
+  bool _internal_has_map() const;
+  public:
+  void clear_map();
+  const ::substrait::ParameterizedType_ParameterizedMap& map() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedMap* release_map();
+  ::substrait::ParameterizedType_ParameterizedMap* mutable_map();
+  void set_allocated_map(::substrait::ParameterizedType_ParameterizedMap* map);
+  private:
+  const ::substrait::ParameterizedType_ParameterizedMap& _internal_map() const;
+  ::substrait::ParameterizedType_ParameterizedMap* _internal_mutable_map();
+  public:
+  void unsafe_arena_set_allocated_map(
+      ::substrait::ParameterizedType_ParameterizedMap* map);
+  ::substrait::ParameterizedType_ParameterizedMap* unsafe_arena_release_map();
+
+  // uint32 user_defined_pointer = 31;
+  bool has_user_defined_pointer() const;
+  private:
+  bool _internal_has_user_defined_pointer() const;
+  public:
+  void clear_user_defined_pointer();
+  uint32_t user_defined_pointer() const;
+  void set_user_defined_pointer(uint32_t value);
+  private:
+  uint32_t _internal_user_defined_pointer() const;
+  void _internal_set_user_defined_pointer(uint32_t value);
+  public:
+
+  // .substrait.ParameterizedType.TypeParameter type_parameter = 33;
+  bool has_type_parameter() const;
+  private:
+  bool _internal_has_type_parameter() const;
+  public:
+  void clear_type_parameter();
+  const ::substrait::ParameterizedType_TypeParameter& type_parameter() const;
+  PROTOBUF_NODISCARD ::substrait::ParameterizedType_TypeParameter* release_type_parameter();
+  ::substrait::ParameterizedType_TypeParameter* mutable_type_parameter();
+  void set_allocated_type_parameter(::substrait::ParameterizedType_TypeParameter* type_parameter);
+  private:
+  const ::substrait::ParameterizedType_TypeParameter& _internal_type_parameter() const;
+  ::substrait::ParameterizedType_TypeParameter* _internal_mutable_type_parameter();
+  public:
+  void unsafe_arena_set_allocated_type_parameter(
+      ::substrait::ParameterizedType_TypeParameter* type_parameter);
+  ::substrait::ParameterizedType_TypeParameter* unsafe_arena_release_type_parameter();
+
+  void clear_kind();
+  KindCase kind_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.ParameterizedType)
+ private:
+  class _Internal;
+  void set_has_bool_();
+  void set_has_i8();
+  void set_has_i16();
+  void set_has_i32();
+  void set_has_i64();
+  void set_has_fp32();
+  void set_has_fp64();
+  void set_has_string();
+  void set_has_binary();
+  void set_has_timestamp();
+  void set_has_date();
+  void set_has_time();
+  void set_has_interval_year();
+  void set_has_interval_day();
+  void set_has_timestamp_tz();
+  void set_has_uuid();
+  void set_has_fixed_char();
+  void set_has_varchar();
+  void set_has_fixed_binary();
+  void set_has_decimal();
+  void set_has_struct_();
+  void set_has_list();
+  void set_has_map();
+  void set_has_user_defined_pointer();
+  void set_has_type_parameter();
+
+  inline bool has_kind() const;
+  inline void clear_has_kind();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union KindUnion {
+    constexpr KindUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Type_Boolean* bool__;
+    ::substrait::Type_I8* i8_;
+    ::substrait::Type_I16* i16_;
+    ::substrait::Type_I32* i32_;
+    ::substrait::Type_I64* i64_;
+    ::substrait::Type_FP32* fp32_;
+    ::substrait::Type_FP64* fp64_;
+    ::substrait::Type_String* string_;
+    ::substrait::Type_Binary* binary_;
+    ::substrait::Type_Timestamp* timestamp_;
+    ::substrait::Type_Date* date_;
+    ::substrait::Type_Time* time_;
+    ::substrait::Type_IntervalYear* interval_year_;
+    ::substrait::Type_IntervalDay* interval_day_;
+    ::substrait::Type_TimestampTZ* timestamp_tz_;
+    ::substrait::Type_UUID* uuid_;
+    ::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char_;
+    ::substrait::ParameterizedType_ParameterizedVarChar* varchar_;
+    ::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary_;
+    ::substrait::ParameterizedType_ParameterizedDecimal* decimal_;
+    ::substrait::ParameterizedType_ParameterizedStruct* struct__;
+    ::substrait::ParameterizedType_ParameterizedList* list_;
+    ::substrait::ParameterizedType_ParameterizedMap* map_;
+    uint32_t user_defined_pointer_;
+    ::substrait::ParameterizedType_TypeParameter* type_parameter_;
+  } kind_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ParameterizedType_TypeParameter
+
+// string name = 1;
+inline void ParameterizedType_TypeParameter::clear_name() {
+  name_.ClearToEmpty();
+}
+inline const std::string& ParameterizedType_TypeParameter::name() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.TypeParameter.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ParameterizedType_TypeParameter::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.TypeParameter.name)
+}
+inline std::string* ParameterizedType_TypeParameter::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.TypeParameter.name)
+  return _s;
+}
+inline const std::string& ParameterizedType_TypeParameter::_internal_name() const {
+  return name_.Get();
+}
+inline void ParameterizedType_TypeParameter::_internal_set_name(const std::string& value) {
+  
+  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ParameterizedType_TypeParameter::_internal_mutable_name() {
+  
+  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ParameterizedType_TypeParameter::release_name() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.TypeParameter.name)
+  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ParameterizedType_TypeParameter::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.TypeParameter.name)
+}
+
+// repeated .substrait.ParameterizedType bounds = 2;
+inline int ParameterizedType_TypeParameter::_internal_bounds_size() const {
+  return bounds_.size();
+}
+inline int ParameterizedType_TypeParameter::bounds_size() const {
+  return _internal_bounds_size();
+}
+inline void ParameterizedType_TypeParameter::clear_bounds() {
+  bounds_.Clear();
+}
+inline ::substrait::ParameterizedType* ParameterizedType_TypeParameter::mutable_bounds(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.TypeParameter.bounds)
+  return bounds_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >*
+ParameterizedType_TypeParameter::mutable_bounds() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.ParameterizedType.TypeParameter.bounds)
+  return &bounds_;
+}
+inline const ::substrait::ParameterizedType& ParameterizedType_TypeParameter::_internal_bounds(int index) const {
+  return bounds_.Get(index);
+}
+inline const ::substrait::ParameterizedType& ParameterizedType_TypeParameter::bounds(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.TypeParameter.bounds)
+  return _internal_bounds(index);
+}
+inline ::substrait::ParameterizedType* ParameterizedType_TypeParameter::_internal_add_bounds() {
+  return bounds_.Add();
+}
+inline ::substrait::ParameterizedType* ParameterizedType_TypeParameter::add_bounds() {
+  ::substrait::ParameterizedType* _add = _internal_add_bounds();
+  // @@protoc_insertion_point(field_add:substrait.ParameterizedType.TypeParameter.bounds)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >&
+ParameterizedType_TypeParameter::bounds() const {
+  // @@protoc_insertion_point(field_list:substrait.ParameterizedType.TypeParameter.bounds)
+  return bounds_;
+}
+
+// -------------------------------------------------------------------
+
+// ParameterizedType_IntegerParameter
+
+// string name = 1;
+inline void ParameterizedType_IntegerParameter::clear_name() {
+  name_.ClearToEmpty();
+}
+inline const std::string& ParameterizedType_IntegerParameter::name() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerParameter.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ParameterizedType_IntegerParameter::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.IntegerParameter.name)
+}
+inline std::string* ParameterizedType_IntegerParameter::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerParameter.name)
+  return _s;
+}
+inline const std::string& ParameterizedType_IntegerParameter::_internal_name() const {
+  return name_.Get();
+}
+inline void ParameterizedType_IntegerParameter::_internal_set_name(const std::string& value) {
+  
+  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ParameterizedType_IntegerParameter::_internal_mutable_name() {
+  
+  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ParameterizedType_IntegerParameter::release_name() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerParameter.name)
+  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ParameterizedType_IntegerParameter::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerParameter.name)
+}
+
+// .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2;
+inline bool ParameterizedType_IntegerParameter::_internal_has_range_start_inclusive() const {
+  return this != internal_default_instance() && range_start_inclusive_ != nullptr;
+}
+inline bool ParameterizedType_IntegerParameter::has_range_start_inclusive() const {
+  return _internal_has_range_start_inclusive();
+}
+inline void ParameterizedType_IntegerParameter::clear_range_start_inclusive() {
+  if (GetArenaForAllocation() == nullptr && range_start_inclusive_ != nullptr) {
+    delete range_start_inclusive_;
+  }
+  range_start_inclusive_ = nullptr;
+}
+inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_internal_range_start_inclusive() const {
+  const ::substrait::ParameterizedType_NullableInteger* p = range_start_inclusive_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType_NullableInteger&>(
+      ::substrait::_ParameterizedType_NullableInteger_default_instance_);
+}
+inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::range_start_inclusive() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerParameter.range_start_inclusive)
+  return _internal_range_start_inclusive();
+}
+inline void ParameterizedType_IntegerParameter::unsafe_arena_set_allocated_range_start_inclusive(
+    ::substrait::ParameterizedType_NullableInteger* range_start_inclusive) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(range_start_inclusive_);
+  }
+  range_start_inclusive_ = range_start_inclusive;
+  if (range_start_inclusive) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.IntegerParameter.range_start_inclusive)
+}
+inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::release_range_start_inclusive() {
+  
+  ::substrait::ParameterizedType_NullableInteger* temp = range_start_inclusive_;
+  range_start_inclusive_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::unsafe_arena_release_range_start_inclusive() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerParameter.range_start_inclusive)
+  
+  ::substrait::ParameterizedType_NullableInteger* temp = range_start_inclusive_;
+  range_start_inclusive_ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::_internal_mutable_range_start_inclusive() {
+  
+  if (range_start_inclusive_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(GetArenaForAllocation());
+    range_start_inclusive_ = p;
+  }
+  return range_start_inclusive_;
+}
+inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::mutable_range_start_inclusive() {
+  ::substrait::ParameterizedType_NullableInteger* _msg = _internal_mutable_range_start_inclusive();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerParameter.range_start_inclusive)
+  return _msg;
+}
+inline void ParameterizedType_IntegerParameter::set_allocated_range_start_inclusive(::substrait::ParameterizedType_NullableInteger* range_start_inclusive) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete range_start_inclusive_;
+  }
+  if (range_start_inclusive) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_NullableInteger>::GetOwningArena(range_start_inclusive);
+    if (message_arena != submessage_arena) {
+      range_start_inclusive = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, range_start_inclusive, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  range_start_inclusive_ = range_start_inclusive;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerParameter.range_start_inclusive)
+}
+
+// .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3;
+inline bool ParameterizedType_IntegerParameter::_internal_has_range_end_exclusive() const {
+  return this != internal_default_instance() && range_end_exclusive_ != nullptr;
+}
+inline bool ParameterizedType_IntegerParameter::has_range_end_exclusive() const {
+  return _internal_has_range_end_exclusive();
+}
+inline void ParameterizedType_IntegerParameter::clear_range_end_exclusive() {
+  if (GetArenaForAllocation() == nullptr && range_end_exclusive_ != nullptr) {
+    delete range_end_exclusive_;
+  }
+  range_end_exclusive_ = nullptr;
+}
+inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_internal_range_end_exclusive() const {
+  const ::substrait::ParameterizedType_NullableInteger* p = range_end_exclusive_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType_NullableInteger&>(
+      ::substrait::_ParameterizedType_NullableInteger_default_instance_);
+}
+inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::range_end_exclusive() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerParameter.range_end_exclusive)
+  return _internal_range_end_exclusive();
+}
+inline void ParameterizedType_IntegerParameter::unsafe_arena_set_allocated_range_end_exclusive(
+    ::substrait::ParameterizedType_NullableInteger* range_end_exclusive) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(range_end_exclusive_);
+  }
+  range_end_exclusive_ = range_end_exclusive;
+  if (range_end_exclusive) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.IntegerParameter.range_end_exclusive)
+}
+inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::release_range_end_exclusive() {
+  
+  ::substrait::ParameterizedType_NullableInteger* temp = range_end_exclusive_;
+  range_end_exclusive_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::unsafe_arena_release_range_end_exclusive() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerParameter.range_end_exclusive)
+  
+  ::substrait::ParameterizedType_NullableInteger* temp = range_end_exclusive_;
+  range_end_exclusive_ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::_internal_mutable_range_end_exclusive() {
+  
+  if (range_end_exclusive_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(GetArenaForAllocation());
+    range_end_exclusive_ = p;
+  }
+  return range_end_exclusive_;
+}
+inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::mutable_range_end_exclusive() {
+  ::substrait::ParameterizedType_NullableInteger* _msg = _internal_mutable_range_end_exclusive();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerParameter.range_end_exclusive)
+  return _msg;
+}
+inline void ParameterizedType_IntegerParameter::set_allocated_range_end_exclusive(::substrait::ParameterizedType_NullableInteger* range_end_exclusive) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete range_end_exclusive_;
+  }
+  if (range_end_exclusive) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_NullableInteger>::GetOwningArena(range_end_exclusive);
+    if (message_arena != submessage_arena) {
+      range_end_exclusive = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, range_end_exclusive, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  range_end_exclusive_ = range_end_exclusive;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerParameter.range_end_exclusive)
+}
+
+// -------------------------------------------------------------------
+
+// ParameterizedType_NullableInteger
+
+// int64 value = 1;
+inline void ParameterizedType_NullableInteger::clear_value() {
+  value_ = int64_t{0};
+}
+inline int64_t ParameterizedType_NullableInteger::_internal_value() const {
+  return value_;
+}
+inline int64_t ParameterizedType_NullableInteger::value() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.NullableInteger.value)
+  return _internal_value();
+}
+inline void ParameterizedType_NullableInteger::_internal_set_value(int64_t value) {
+  
+  value_ = value;
+}
+inline void ParameterizedType_NullableInteger::set_value(int64_t value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.NullableInteger.value)
+}
+
+// -------------------------------------------------------------------
+
+// ParameterizedType_ParameterizedFixedChar
+
+// .substrait.ParameterizedType.IntegerOption length = 1;
+inline bool ParameterizedType_ParameterizedFixedChar::_internal_has_length() const {
+  return this != internal_default_instance() && length_ != nullptr;
+}
+inline bool ParameterizedType_ParameterizedFixedChar::has_length() const {
+  return _internal_has_length();
+}
+inline void ParameterizedType_ParameterizedFixedChar::clear_length() {
+  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
+    delete length_;
+  }
+  length_ = nullptr;
+}
+inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::_internal_length() const {
+  const ::substrait::ParameterizedType_IntegerOption* p = length_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType_IntegerOption&>(
+      ::substrait::_ParameterizedType_IntegerOption_default_instance_);
+}
+inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::length() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedChar.length)
+  return _internal_length();
+}
+inline void ParameterizedType_ParameterizedFixedChar::unsafe_arena_set_allocated_length(
+    ::substrait::ParameterizedType_IntegerOption* length) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_);
+  }
+  length_ = length;
+  if (length) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedFixedChar.length)
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::release_length() {
+  
+  ::substrait::ParameterizedType_IntegerOption* temp = length_;
+  length_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::unsafe_arena_release_length() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedFixedChar.length)
+  
+  ::substrait::ParameterizedType_IntegerOption* temp = length_;
+  length_ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::_internal_mutable_length() {
+  
+  if (length_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation());
+    length_ = p;
+  }
+  return length_;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::mutable_length() {
+  ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_length();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedFixedChar.length)
+  return _msg;
+}
+inline void ParameterizedType_ParameterizedFixedChar::set_allocated_length(::substrait::ParameterizedType_IntegerOption* length) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete length_;
+  }
+  if (length) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(length);
+    if (message_arena != submessage_arena) {
+      length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, length, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  length_ = length;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedFixedChar.length)
+}
+
+// uint32 variation_pointer = 2;
+inline void ParameterizedType_ParameterizedFixedChar::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t ParameterizedType_ParameterizedFixedChar::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t ParameterizedType_ParameterizedFixedChar::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedChar.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void ParameterizedType_ParameterizedFixedChar::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void ParameterizedType_ParameterizedFixedChar::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedChar.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void ParameterizedType_ParameterizedFixedChar::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedFixedChar::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedFixedChar::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedChar.nullability)
+  return _internal_nullability();
+}
+inline void ParameterizedType_ParameterizedFixedChar::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void ParameterizedType_ParameterizedFixedChar::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedChar.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// ParameterizedType_ParameterizedVarChar
+
+// .substrait.ParameterizedType.IntegerOption length = 1;
+inline bool ParameterizedType_ParameterizedVarChar::_internal_has_length() const {
+  return this != internal_default_instance() && length_ != nullptr;
+}
+inline bool ParameterizedType_ParameterizedVarChar::has_length() const {
+  return _internal_has_length();
+}
+inline void ParameterizedType_ParameterizedVarChar::clear_length() {
+  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
+    delete length_;
+  }
+  length_ = nullptr;
+}
+inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::_internal_length() const {
+  const ::substrait::ParameterizedType_IntegerOption* p = length_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType_IntegerOption&>(
+      ::substrait::_ParameterizedType_IntegerOption_default_instance_);
+}
+inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::length() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedVarChar.length)
+  return _internal_length();
+}
+inline void ParameterizedType_ParameterizedVarChar::unsafe_arena_set_allocated_length(
+    ::substrait::ParameterizedType_IntegerOption* length) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_);
+  }
+  length_ = length;
+  if (length) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedVarChar.length)
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::release_length() {
+  
+  ::substrait::ParameterizedType_IntegerOption* temp = length_;
+  length_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::unsafe_arena_release_length() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedVarChar.length)
+  
+  ::substrait::ParameterizedType_IntegerOption* temp = length_;
+  length_ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::_internal_mutable_length() {
+  
+  if (length_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation());
+    length_ = p;
+  }
+  return length_;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::mutable_length() {
+  ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_length();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedVarChar.length)
+  return _msg;
+}
+inline void ParameterizedType_ParameterizedVarChar::set_allocated_length(::substrait::ParameterizedType_IntegerOption* length) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete length_;
+  }
+  if (length) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(length);
+    if (message_arena != submessage_arena) {
+      length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, length, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  length_ = length;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedVarChar.length)
+}
+
+// uint32 variation_pointer = 2;
+inline void ParameterizedType_ParameterizedVarChar::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t ParameterizedType_ParameterizedVarChar::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t ParameterizedType_ParameterizedVarChar::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedVarChar.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void ParameterizedType_ParameterizedVarChar::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void ParameterizedType_ParameterizedVarChar::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedVarChar.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void ParameterizedType_ParameterizedVarChar::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedVarChar::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedVarChar::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedVarChar.nullability)
+  return _internal_nullability();
+}
+inline void ParameterizedType_ParameterizedVarChar::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void ParameterizedType_ParameterizedVarChar::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedVarChar.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// ParameterizedType_ParameterizedFixedBinary
+
+// .substrait.ParameterizedType.IntegerOption length = 1;
+inline bool ParameterizedType_ParameterizedFixedBinary::_internal_has_length() const {
+  return this != internal_default_instance() && length_ != nullptr;
+}
+inline bool ParameterizedType_ParameterizedFixedBinary::has_length() const {
+  return _internal_has_length();
+}
+inline void ParameterizedType_ParameterizedFixedBinary::clear_length() {
+  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
+    delete length_;
+  }
+  length_ = nullptr;
+}
+inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::_internal_length() const {
+  const ::substrait::ParameterizedType_IntegerOption* p = length_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType_IntegerOption&>(
+      ::substrait::_ParameterizedType_IntegerOption_default_instance_);
+}
+inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::length() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedBinary.length)
+  return _internal_length();
+}
+inline void ParameterizedType_ParameterizedFixedBinary::unsafe_arena_set_allocated_length(
+    ::substrait::ParameterizedType_IntegerOption* length) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_);
+  }
+  length_ = length;
+  if (length) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedFixedBinary.length)
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::release_length() {
+  
+  ::substrait::ParameterizedType_IntegerOption* temp = length_;
+  length_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::unsafe_arena_release_length() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedFixedBinary.length)
+  
+  ::substrait::ParameterizedType_IntegerOption* temp = length_;
+  length_ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::_internal_mutable_length() {
+  
+  if (length_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation());
+    length_ = p;
+  }
+  return length_;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::mutable_length() {
+  ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_length();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedFixedBinary.length)
+  return _msg;
+}
+inline void ParameterizedType_ParameterizedFixedBinary::set_allocated_length(::substrait::ParameterizedType_IntegerOption* length) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete length_;
+  }
+  if (length) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(length);
+    if (message_arena != submessage_arena) {
+      length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, length, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  length_ = length;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedFixedBinary.length)
+}
+
+// uint32 variation_pointer = 2;
+inline void ParameterizedType_ParameterizedFixedBinary::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t ParameterizedType_ParameterizedFixedBinary::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t ParameterizedType_ParameterizedFixedBinary::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedBinary.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void ParameterizedType_ParameterizedFixedBinary::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void ParameterizedType_ParameterizedFixedBinary::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedBinary.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void ParameterizedType_ParameterizedFixedBinary::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedFixedBinary::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedFixedBinary::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedBinary.nullability)
+  return _internal_nullability();
+}
+inline void ParameterizedType_ParameterizedFixedBinary::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void ParameterizedType_ParameterizedFixedBinary::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedBinary.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// ParameterizedType_ParameterizedDecimal
+
+// .substrait.ParameterizedType.IntegerOption scale = 1;
+inline bool ParameterizedType_ParameterizedDecimal::_internal_has_scale() const {
+  return this != internal_default_instance() && scale_ != nullptr;
+}
+inline bool ParameterizedType_ParameterizedDecimal::has_scale() const {
+  return _internal_has_scale();
+}
+inline void ParameterizedType_ParameterizedDecimal::clear_scale() {
+  if (GetArenaForAllocation() == nullptr && scale_ != nullptr) {
+    delete scale_;
+  }
+  scale_ = nullptr;
+}
+inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_internal_scale() const {
+  const ::substrait::ParameterizedType_IntegerOption* p = scale_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType_IntegerOption&>(
+      ::substrait::_ParameterizedType_IntegerOption_default_instance_);
+}
+inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::scale() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.scale)
+  return _internal_scale();
+}
+inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_scale(
+    ::substrait::ParameterizedType_IntegerOption* scale) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_);
+  }
+  scale_ = scale;
+  if (scale) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedDecimal.scale)
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::release_scale() {
+  
+  ::substrait::ParameterizedType_IntegerOption* temp = scale_;
+  scale_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_scale() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedDecimal.scale)
+  
+  ::substrait::ParameterizedType_IntegerOption* temp = scale_;
+  scale_ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::_internal_mutable_scale() {
+  
+  if (scale_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation());
+    scale_ = p;
+  }
+  return scale_;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::mutable_scale() {
+  ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_scale();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedDecimal.scale)
+  return _msg;
+}
+inline void ParameterizedType_ParameterizedDecimal::set_allocated_scale(::substrait::ParameterizedType_IntegerOption* scale) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete scale_;
+  }
+  if (scale) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(scale);
+    if (message_arena != submessage_arena) {
+      scale = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, scale, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  scale_ = scale;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedDecimal.scale)
+}
+
+// .substrait.ParameterizedType.IntegerOption precision = 2;
+inline bool ParameterizedType_ParameterizedDecimal::_internal_has_precision() const {
+  return this != internal_default_instance() && precision_ != nullptr;
+}
+inline bool ParameterizedType_ParameterizedDecimal::has_precision() const {
+  return _internal_has_precision();
+}
+inline void ParameterizedType_ParameterizedDecimal::clear_precision() {
+  if (GetArenaForAllocation() == nullptr && precision_ != nullptr) {
+    delete precision_;
+  }
+  precision_ = nullptr;
+}
+inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_internal_precision() const {
+  const ::substrait::ParameterizedType_IntegerOption* p = precision_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType_IntegerOption&>(
+      ::substrait::_ParameterizedType_IntegerOption_default_instance_);
+}
+inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::precision() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.precision)
+  return _internal_precision();
+}
+inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_precision(
+    ::substrait::ParameterizedType_IntegerOption* precision) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(precision_);
+  }
+  precision_ = precision;
+  if (precision) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedDecimal.precision)
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::release_precision() {
+  
+  ::substrait::ParameterizedType_IntegerOption* temp = precision_;
+  precision_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_precision() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedDecimal.precision)
+  
+  ::substrait::ParameterizedType_IntegerOption* temp = precision_;
+  precision_ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::_internal_mutable_precision() {
+  
+  if (precision_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation());
+    precision_ = p;
+  }
+  return precision_;
+}
+inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::mutable_precision() {
+  ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_precision();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedDecimal.precision)
+  return _msg;
+}
+inline void ParameterizedType_ParameterizedDecimal::set_allocated_precision(::substrait::ParameterizedType_IntegerOption* precision) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete precision_;
+  }
+  if (precision) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(precision);
+    if (message_arena != submessage_arena) {
+      precision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, precision, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  precision_ = precision;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedDecimal.precision)
+}
+
+// uint32 variation_pointer = 3;
+inline void ParameterizedType_ParameterizedDecimal::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t ParameterizedType_ParameterizedDecimal::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t ParameterizedType_ParameterizedDecimal::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void ParameterizedType_ParameterizedDecimal::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void ParameterizedType_ParameterizedDecimal::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedDecimal.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 4;
+inline void ParameterizedType_ParameterizedDecimal::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedDecimal::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedDecimal::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.nullability)
+  return _internal_nullability();
+}
+inline void ParameterizedType_ParameterizedDecimal::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void ParameterizedType_ParameterizedDecimal::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedDecimal.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// ParameterizedType_ParameterizedStruct
+
+// repeated .substrait.ParameterizedType types = 1;
+inline int ParameterizedType_ParameterizedStruct::_internal_types_size() const {
+  return types_.size();
+}
+inline int ParameterizedType_ParameterizedStruct::types_size() const {
+  return _internal_types_size();
+}
+inline void ParameterizedType_ParameterizedStruct::clear_types() {
+  types_.Clear();
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::mutable_types(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedStruct.types)
+  return types_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >*
+ParameterizedType_ParameterizedStruct::mutable_types() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.ParameterizedType.ParameterizedStruct.types)
+  return &types_;
+}
+inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedStruct::_internal_types(int index) const {
+  return types_.Get(index);
+}
+inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedStruct::types(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedStruct.types)
+  return _internal_types(index);
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::_internal_add_types() {
+  return types_.Add();
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::add_types() {
+  ::substrait::ParameterizedType* _add = _internal_add_types();
+  // @@protoc_insertion_point(field_add:substrait.ParameterizedType.ParameterizedStruct.types)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >&
+ParameterizedType_ParameterizedStruct::types() const {
+  // @@protoc_insertion_point(field_list:substrait.ParameterizedType.ParameterizedStruct.types)
+  return types_;
+}
+
+// uint32 variation_pointer = 2;
+inline void ParameterizedType_ParameterizedStruct::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t ParameterizedType_ParameterizedStruct::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t ParameterizedType_ParameterizedStruct::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedStruct.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void ParameterizedType_ParameterizedStruct::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void ParameterizedType_ParameterizedStruct::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedStruct.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void ParameterizedType_ParameterizedStruct::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedStruct::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedStruct::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedStruct.nullability)
+  return _internal_nullability();
+}
+inline void ParameterizedType_ParameterizedStruct::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void ParameterizedType_ParameterizedStruct::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedStruct.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// ParameterizedType_ParameterizedNamedStruct
+
+// repeated string names = 1;
+inline int ParameterizedType_ParameterizedNamedStruct::_internal_names_size() const {
+  return names_.size();
+}
+inline int ParameterizedType_ParameterizedNamedStruct::names_size() const {
+  return _internal_names_size();
+}
+inline void ParameterizedType_ParameterizedNamedStruct::clear_names() {
+  names_.Clear();
+}
+inline std::string* ParameterizedType_ParameterizedNamedStruct::add_names() {
+  std::string* _s = _internal_add_names();
+  // @@protoc_insertion_point(field_add_mutable:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+  return _s;
+}
+inline const std::string& ParameterizedType_ParameterizedNamedStruct::_internal_names(int index) const {
+  return names_.Get(index);
+}
+inline const std::string& ParameterizedType_ParameterizedNamedStruct::names(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+  return _internal_names(index);
+}
+inline std::string* ParameterizedType_ParameterizedNamedStruct::mutable_names(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+  return names_.Mutable(index);
+}
+inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const std::string& value) {
+  names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+}
+inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, std::string&& value) {
+  names_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+}
+inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+}
+inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const char* value, size_t size) {
+  names_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+}
+inline std::string* ParameterizedType_ParameterizedNamedStruct::_internal_add_names() {
+  return names_.Add();
+}
+inline void ParameterizedType_ParameterizedNamedStruct::add_names(const std::string& value) {
+  names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+}
+inline void ParameterizedType_ParameterizedNamedStruct::add_names(std::string&& value) {
+  names_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+}
+inline void ParameterizedType_ParameterizedNamedStruct::add_names(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+}
+inline void ParameterizedType_ParameterizedNamedStruct::add_names(const char* value, size_t size) {
+  names_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ParameterizedType_ParameterizedNamedStruct::names() const {
+  // @@protoc_insertion_point(field_list:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+  return names_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ParameterizedType_ParameterizedNamedStruct::mutable_names() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.ParameterizedType.ParameterizedNamedStruct.names)
+  return &names_;
+}
+
+// .substrait.ParameterizedType.ParameterizedStruct struct = 2;
+inline bool ParameterizedType_ParameterizedNamedStruct::_internal_has_struct_() const {
+  return this != internal_default_instance() && struct__ != nullptr;
+}
+inline bool ParameterizedType_ParameterizedNamedStruct::has_struct_() const {
+  return _internal_has_struct_();
+}
+inline void ParameterizedType_ParameterizedNamedStruct::clear_struct_() {
+  if (GetArenaForAllocation() == nullptr && struct__ != nullptr) {
+    delete struct__;
+  }
+  struct__ = nullptr;
+}
+inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType_ParameterizedNamedStruct::_internal_struct_() const {
+  const ::substrait::ParameterizedType_ParameterizedStruct* p = struct__;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType_ParameterizedStruct&>(
+      ::substrait::_ParameterizedType_ParameterizedStruct_default_instance_);
+}
+inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType_ParameterizedNamedStruct::struct_() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedNamedStruct.struct)
+  return _internal_struct_();
+}
+inline void ParameterizedType_ParameterizedNamedStruct::unsafe_arena_set_allocated_struct_(
+    ::substrait::ParameterizedType_ParameterizedStruct* struct_) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__);
+  }
+  struct__ = struct_;
+  if (struct_) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedNamedStruct.struct)
+}
+inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::release_struct_() {
+  
+  ::substrait::ParameterizedType_ParameterizedStruct* temp = struct__;
+  struct__ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::unsafe_arena_release_struct_() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedNamedStruct.struct)
+  
+  ::substrait::ParameterizedType_ParameterizedStruct* temp = struct__;
+  struct__ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::_internal_mutable_struct_() {
+  
+  if (struct__ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedStruct>(GetArenaForAllocation());
+    struct__ = p;
+  }
+  return struct__;
+}
+inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::mutable_struct_() {
+  ::substrait::ParameterizedType_ParameterizedStruct* _msg = _internal_mutable_struct_();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedNamedStruct.struct)
+  return _msg;
+}
+inline void ParameterizedType_ParameterizedNamedStruct::set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete struct__;
+  }
+  if (struct_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedStruct>::GetOwningArena(struct_);
+    if (message_arena != submessage_arena) {
+      struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, struct_, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  struct__ = struct_;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedNamedStruct.struct)
+}
+
+// -------------------------------------------------------------------
+
+// ParameterizedType_ParameterizedList
+
+// .substrait.ParameterizedType type = 1;
+inline bool ParameterizedType_ParameterizedList::_internal_has_type() const {
+  return this != internal_default_instance() && type_ != nullptr;
+}
+inline bool ParameterizedType_ParameterizedList::has_type() const {
+  return _internal_has_type();
+}
+inline void ParameterizedType_ParameterizedList::clear_type() {
+  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
+    delete type_;
+  }
+  type_ = nullptr;
+}
+inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedList::_internal_type() const {
+  const ::substrait::ParameterizedType* p = type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType&>(
+      ::substrait::_ParameterizedType_default_instance_);
+}
+inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedList::type() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedList.type)
+  return _internal_type();
+}
+inline void ParameterizedType_ParameterizedList::unsafe_arena_set_allocated_type(
+    ::substrait::ParameterizedType* type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
+  }
+  type_ = type;
+  if (type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedList.type)
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::release_type() {
+  
+  ::substrait::ParameterizedType* temp = type_;
+  type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::unsafe_arena_release_type() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedList.type)
+  
+  ::substrait::ParameterizedType* temp = type_;
+  type_ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::_internal_mutable_type() {
+  
+  if (type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation());
+    type_ = p;
+  }
+  return type_;
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::mutable_type() {
+  ::substrait::ParameterizedType* _msg = _internal_mutable_type();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedList.type)
+  return _msg;
+}
+inline void ParameterizedType_ParameterizedList::set_allocated_type(::substrait::ParameterizedType* type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete type_;
+  }
+  if (type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType>::GetOwningArena(type);
+    if (message_arena != submessage_arena) {
+      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  type_ = type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedList.type)
+}
+
+// uint32 variation_pointer = 2;
+inline void ParameterizedType_ParameterizedList::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t ParameterizedType_ParameterizedList::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t ParameterizedType_ParameterizedList::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedList.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void ParameterizedType_ParameterizedList::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void ParameterizedType_ParameterizedList::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedList.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void ParameterizedType_ParameterizedList::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedList::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedList::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedList.nullability)
+  return _internal_nullability();
+}
+inline void ParameterizedType_ParameterizedList::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void ParameterizedType_ParameterizedList::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedList.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// ParameterizedType_ParameterizedMap
+
+// .substrait.ParameterizedType key = 1;
+inline bool ParameterizedType_ParameterizedMap::_internal_has_key() const {
+  return this != internal_default_instance() && key_ != nullptr;
+}
+inline bool ParameterizedType_ParameterizedMap::has_key() const {
+  return _internal_has_key();
+}
+inline void ParameterizedType_ParameterizedMap::clear_key() {
+  if (GetArenaForAllocation() == nullptr && key_ != nullptr) {
+    delete key_;
+  }
+  key_ = nullptr;
+}
+inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_internal_key() const {
+  const ::substrait::ParameterizedType* p = key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType&>(
+      ::substrait::_ParameterizedType_default_instance_);
+}
+inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::key() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.key)
+  return _internal_key();
+}
+inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_key(
+    ::substrait::ParameterizedType* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_);
+  }
+  key_ = key;
+  if (key) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedMap.key)
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::release_key() {
+  
+  ::substrait::ParameterizedType* temp = key_;
+  key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedMap.key)
+  
+  ::substrait::ParameterizedType* temp = key_;
+  key_ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::_internal_mutable_key() {
+  
+  if (key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation());
+    key_ = p;
+  }
+  return key_;
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::mutable_key() {
+  ::substrait::ParameterizedType* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedMap.key)
+  return _msg;
+}
+inline void ParameterizedType_ParameterizedMap::set_allocated_key(::substrait::ParameterizedType* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType>::GetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedMap.key)
+}
+
+// .substrait.ParameterizedType value = 2;
+inline bool ParameterizedType_ParameterizedMap::_internal_has_value() const {
+  return this != internal_default_instance() && value_ != nullptr;
+}
+inline bool ParameterizedType_ParameterizedMap::has_value() const {
+  return _internal_has_value();
+}
+inline void ParameterizedType_ParameterizedMap::clear_value() {
+  if (GetArenaForAllocation() == nullptr && value_ != nullptr) {
+    delete value_;
+  }
+  value_ = nullptr;
+}
+inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_internal_value() const {
+  const ::substrait::ParameterizedType* p = value_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::ParameterizedType&>(
+      ::substrait::_ParameterizedType_default_instance_);
+}
+inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::value() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.value)
+  return _internal_value();
+}
+inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_value(
+    ::substrait::ParameterizedType* value) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
+  }
+  value_ = value;
+  if (value) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedMap.value)
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::release_value() {
+  
+  ::substrait::ParameterizedType* temp = value_;
+  value_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedMap.value)
+  
+  ::substrait::ParameterizedType* temp = value_;
+  value_ = nullptr;
+  return temp;
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::_internal_mutable_value() {
+  
+  if (value_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation());
+    value_ = p;
+  }
+  return value_;
+}
+inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::mutable_value() {
+  ::substrait::ParameterizedType* _msg = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedMap.value)
+  return _msg;
+}
+inline void ParameterizedType_ParameterizedMap::set_allocated_value(::substrait::ParameterizedType* value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete value_;
+  }
+  if (value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType>::GetOwningArena(value);
+    if (message_arena != submessage_arena) {
+      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  value_ = value;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedMap.value)
+}
+
+// uint32 variation_pointer = 3;
+inline void ParameterizedType_ParameterizedMap::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t ParameterizedType_ParameterizedMap::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t ParameterizedType_ParameterizedMap::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void ParameterizedType_ParameterizedMap::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void ParameterizedType_ParameterizedMap::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedMap.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 4;
+inline void ParameterizedType_ParameterizedMap::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedMap::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability ParameterizedType_ParameterizedMap::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.nullability)
+  return _internal_nullability();
+}
+inline void ParameterizedType_ParameterizedMap::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void ParameterizedType_ParameterizedMap::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedMap.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// ParameterizedType_IntegerOption
+
+// int32 literal = 1;
+inline bool ParameterizedType_IntegerOption::_internal_has_literal() const {
+  return integer_type_case() == kLiteral;
+}
+inline bool ParameterizedType_IntegerOption::has_literal() const {
+  return _internal_has_literal();
+}
+inline void ParameterizedType_IntegerOption::set_has_literal() {
+  _oneof_case_[0] = kLiteral;
+}
+inline void ParameterizedType_IntegerOption::clear_literal() {
+  if (_internal_has_literal()) {
+    integer_type_.literal_ = 0;
+    clear_has_integer_type();
+  }
+}
+inline int32_t ParameterizedType_IntegerOption::_internal_literal() const {
+  if (_internal_has_literal()) {
+    return integer_type_.literal_;
+  }
+  return 0;
+}
+inline void ParameterizedType_IntegerOption::_internal_set_literal(int32_t value) {
+  if (!_internal_has_literal()) {
+    clear_integer_type();
+    set_has_literal();
+  }
+  integer_type_.literal_ = value;
+}
+inline int32_t ParameterizedType_IntegerOption::literal() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerOption.literal)
+  return _internal_literal();
+}
+inline void ParameterizedType_IntegerOption::set_literal(int32_t value) {
+  _internal_set_literal(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.IntegerOption.literal)
+}
+
+// .substrait.ParameterizedType.IntegerParameter parameter = 2;
+inline bool ParameterizedType_IntegerOption::_internal_has_parameter() const {
+  return integer_type_case() == kParameter;
+}
+inline bool ParameterizedType_IntegerOption::has_parameter() const {
+  return _internal_has_parameter();
+}
+inline void ParameterizedType_IntegerOption::set_has_parameter() {
+  _oneof_case_[0] = kParameter;
+}
+inline void ParameterizedType_IntegerOption::clear_parameter() {
+  if (_internal_has_parameter()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete integer_type_.parameter_;
+    }
+    clear_has_integer_type();
+  }
+}
+inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::release_parameter() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerOption.parameter)
+  if (_internal_has_parameter()) {
+    clear_has_integer_type();
+      ::substrait::ParameterizedType_IntegerParameter* temp = integer_type_.parameter_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    integer_type_.parameter_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ParameterizedType_IntegerParameter& ParameterizedType_IntegerOption::_internal_parameter() const {
+  return _internal_has_parameter()
+      ? *integer_type_.parameter_
+      : reinterpret_cast< ::substrait::ParameterizedType_IntegerParameter&>(::substrait::_ParameterizedType_IntegerParameter_default_instance_);
+}
+inline const ::substrait::ParameterizedType_IntegerParameter& ParameterizedType_IntegerOption::parameter() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerOption.parameter)
+  return _internal_parameter();
+}
+inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::unsafe_arena_release_parameter() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.IntegerOption.parameter)
+  if (_internal_has_parameter()) {
+    clear_has_integer_type();
+    ::substrait::ParameterizedType_IntegerParameter* temp = integer_type_.parameter_;
+    integer_type_.parameter_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType_IntegerOption::unsafe_arena_set_allocated_parameter(::substrait::ParameterizedType_IntegerParameter* parameter) {
+  clear_integer_type();
+  if (parameter) {
+    set_has_parameter();
+    integer_type_.parameter_ = parameter;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.IntegerOption.parameter)
+}
+inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::_internal_mutable_parameter() {
+  if (!_internal_has_parameter()) {
+    clear_integer_type();
+    set_has_parameter();
+    integer_type_.parameter_ = CreateMaybeMessage< ::substrait::ParameterizedType_IntegerParameter >(GetArenaForAllocation());
+  }
+  return integer_type_.parameter_;
+}
+inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::mutable_parameter() {
+  ::substrait::ParameterizedType_IntegerParameter* _msg = _internal_mutable_parameter();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerOption.parameter)
+  return _msg;
+}
+
+inline bool ParameterizedType_IntegerOption::has_integer_type() const {
+  return integer_type_case() != INTEGER_TYPE_NOT_SET;
+}
+inline void ParameterizedType_IntegerOption::clear_has_integer_type() {
+  _oneof_case_[0] = INTEGER_TYPE_NOT_SET;
+}
+inline ParameterizedType_IntegerOption::IntegerTypeCase ParameterizedType_IntegerOption::integer_type_case() const {
+  return ParameterizedType_IntegerOption::IntegerTypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ParameterizedType
+
+// .substrait.Type.Boolean bool = 1;
+inline bool ParameterizedType::_internal_has_bool_() const {
+  return kind_case() == kBool;
+}
+inline bool ParameterizedType::has_bool_() const {
+  return _internal_has_bool_();
+}
+inline void ParameterizedType::set_has_bool_() {
+  _oneof_case_[0] = kBool;
+}
+inline ::substrait::Type_Boolean* ParameterizedType::release_bool_() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.bool)
+  if (_internal_has_bool_()) {
+    clear_has_kind();
+      ::substrait::Type_Boolean* temp = kind_.bool__;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.bool__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Boolean& ParameterizedType::_internal_bool_() const {
+  return _internal_has_bool_()
+      ? *kind_.bool__
+      : reinterpret_cast< ::substrait::Type_Boolean&>(::substrait::_Type_Boolean_default_instance_);
+}
+inline const ::substrait::Type_Boolean& ParameterizedType::bool_() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.bool)
+  return _internal_bool_();
+}
+inline ::substrait::Type_Boolean* ParameterizedType::unsafe_arena_release_bool_() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.bool)
+  if (_internal_has_bool_()) {
+    clear_has_kind();
+    ::substrait::Type_Boolean* temp = kind_.bool__;
+    kind_.bool__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_bool_(::substrait::Type_Boolean* bool_) {
+  clear_kind();
+  if (bool_) {
+    set_has_bool_();
+    kind_.bool__ = bool_;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.bool)
+}
+inline ::substrait::Type_Boolean* ParameterizedType::_internal_mutable_bool_() {
+  if (!_internal_has_bool_()) {
+    clear_kind();
+    set_has_bool_();
+    kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArenaForAllocation());
+  }
+  return kind_.bool__;
+}
+inline ::substrait::Type_Boolean* ParameterizedType::mutable_bool_() {
+  ::substrait::Type_Boolean* _msg = _internal_mutable_bool_();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.bool)
+  return _msg;
+}
+
+// .substrait.Type.I8 i8 = 2;
+inline bool ParameterizedType::_internal_has_i8() const {
+  return kind_case() == kI8;
+}
+inline bool ParameterizedType::has_i8() const {
+  return _internal_has_i8();
+}
+inline void ParameterizedType::set_has_i8() {
+  _oneof_case_[0] = kI8;
+}
+inline ::substrait::Type_I8* ParameterizedType::release_i8() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.i8)
+  if (_internal_has_i8()) {
+    clear_has_kind();
+      ::substrait::Type_I8* temp = kind_.i8_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.i8_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_I8& ParameterizedType::_internal_i8() const {
+  return _internal_has_i8()
+      ? *kind_.i8_
+      : reinterpret_cast< ::substrait::Type_I8&>(::substrait::_Type_I8_default_instance_);
+}
+inline const ::substrait::Type_I8& ParameterizedType::i8() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.i8)
+  return _internal_i8();
+}
+inline ::substrait::Type_I8* ParameterizedType::unsafe_arena_release_i8() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.i8)
+  if (_internal_has_i8()) {
+    clear_has_kind();
+    ::substrait::Type_I8* temp = kind_.i8_;
+    kind_.i8_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_i8(::substrait::Type_I8* i8) {
+  clear_kind();
+  if (i8) {
+    set_has_i8();
+    kind_.i8_ = i8;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.i8)
+}
+inline ::substrait::Type_I8* ParameterizedType::_internal_mutable_i8() {
+  if (!_internal_has_i8()) {
+    clear_kind();
+    set_has_i8();
+    kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArenaForAllocation());
+  }
+  return kind_.i8_;
+}
+inline ::substrait::Type_I8* ParameterizedType::mutable_i8() {
+  ::substrait::Type_I8* _msg = _internal_mutable_i8();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i8)
+  return _msg;
+}
+
+// .substrait.Type.I16 i16 = 3;
+inline bool ParameterizedType::_internal_has_i16() const {
+  return kind_case() == kI16;
+}
+inline bool ParameterizedType::has_i16() const {
+  return _internal_has_i16();
+}
+inline void ParameterizedType::set_has_i16() {
+  _oneof_case_[0] = kI16;
+}
+inline ::substrait::Type_I16* ParameterizedType::release_i16() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.i16)
+  if (_internal_has_i16()) {
+    clear_has_kind();
+      ::substrait::Type_I16* temp = kind_.i16_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.i16_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_I16& ParameterizedType::_internal_i16() const {
+  return _internal_has_i16()
+      ? *kind_.i16_
+      : reinterpret_cast< ::substrait::Type_I16&>(::substrait::_Type_I16_default_instance_);
+}
+inline const ::substrait::Type_I16& ParameterizedType::i16() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.i16)
+  return _internal_i16();
+}
+inline ::substrait::Type_I16* ParameterizedType::unsafe_arena_release_i16() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.i16)
+  if (_internal_has_i16()) {
+    clear_has_kind();
+    ::substrait::Type_I16* temp = kind_.i16_;
+    kind_.i16_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_i16(::substrait::Type_I16* i16) {
+  clear_kind();
+  if (i16) {
+    set_has_i16();
+    kind_.i16_ = i16;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.i16)
+}
+inline ::substrait::Type_I16* ParameterizedType::_internal_mutable_i16() {
+  if (!_internal_has_i16()) {
+    clear_kind();
+    set_has_i16();
+    kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArenaForAllocation());
+  }
+  return kind_.i16_;
+}
+inline ::substrait::Type_I16* ParameterizedType::mutable_i16() {
+  ::substrait::Type_I16* _msg = _internal_mutable_i16();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i16)
+  return _msg;
+}
+
+// .substrait.Type.I32 i32 = 5;
+inline bool ParameterizedType::_internal_has_i32() const {
+  return kind_case() == kI32;
+}
+inline bool ParameterizedType::has_i32() const {
+  return _internal_has_i32();
+}
+inline void ParameterizedType::set_has_i32() {
+  _oneof_case_[0] = kI32;
+}
+inline ::substrait::Type_I32* ParameterizedType::release_i32() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.i32)
+  if (_internal_has_i32()) {
+    clear_has_kind();
+      ::substrait::Type_I32* temp = kind_.i32_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.i32_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_I32& ParameterizedType::_internal_i32() const {
+  return _internal_has_i32()
+      ? *kind_.i32_
+      : reinterpret_cast< ::substrait::Type_I32&>(::substrait::_Type_I32_default_instance_);
+}
+inline const ::substrait::Type_I32& ParameterizedType::i32() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.i32)
+  return _internal_i32();
+}
+inline ::substrait::Type_I32* ParameterizedType::unsafe_arena_release_i32() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.i32)
+  if (_internal_has_i32()) {
+    clear_has_kind();
+    ::substrait::Type_I32* temp = kind_.i32_;
+    kind_.i32_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_i32(::substrait::Type_I32* i32) {
+  clear_kind();
+  if (i32) {
+    set_has_i32();
+    kind_.i32_ = i32;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.i32)
+}
+inline ::substrait::Type_I32* ParameterizedType::_internal_mutable_i32() {
+  if (!_internal_has_i32()) {
+    clear_kind();
+    set_has_i32();
+    kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArenaForAllocation());
+  }
+  return kind_.i32_;
+}
+inline ::substrait::Type_I32* ParameterizedType::mutable_i32() {
+  ::substrait::Type_I32* _msg = _internal_mutable_i32();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i32)
+  return _msg;
+}
+
+// .substrait.Type.I64 i64 = 7;
+inline bool ParameterizedType::_internal_has_i64() const {
+  return kind_case() == kI64;
+}
+inline bool ParameterizedType::has_i64() const {
+  return _internal_has_i64();
+}
+inline void ParameterizedType::set_has_i64() {
+  _oneof_case_[0] = kI64;
+}
+inline ::substrait::Type_I64* ParameterizedType::release_i64() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.i64)
+  if (_internal_has_i64()) {
+    clear_has_kind();
+      ::substrait::Type_I64* temp = kind_.i64_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.i64_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_I64& ParameterizedType::_internal_i64() const {
+  return _internal_has_i64()
+      ? *kind_.i64_
+      : reinterpret_cast< ::substrait::Type_I64&>(::substrait::_Type_I64_default_instance_);
+}
+inline const ::substrait::Type_I64& ParameterizedType::i64() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.i64)
+  return _internal_i64();
+}
+inline ::substrait::Type_I64* ParameterizedType::unsafe_arena_release_i64() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.i64)
+  if (_internal_has_i64()) {
+    clear_has_kind();
+    ::substrait::Type_I64* temp = kind_.i64_;
+    kind_.i64_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_i64(::substrait::Type_I64* i64) {
+  clear_kind();
+  if (i64) {
+    set_has_i64();
+    kind_.i64_ = i64;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.i64)
+}
+inline ::substrait::Type_I64* ParameterizedType::_internal_mutable_i64() {
+  if (!_internal_has_i64()) {
+    clear_kind();
+    set_has_i64();
+    kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArenaForAllocation());
+  }
+  return kind_.i64_;
+}
+inline ::substrait::Type_I64* ParameterizedType::mutable_i64() {
+  ::substrait::Type_I64* _msg = _internal_mutable_i64();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i64)
+  return _msg;
+}
+
+// .substrait.Type.FP32 fp32 = 10;
+inline bool ParameterizedType::_internal_has_fp32() const {
+  return kind_case() == kFp32;
+}
+inline bool ParameterizedType::has_fp32() const {
+  return _internal_has_fp32();
+}
+inline void ParameterizedType::set_has_fp32() {
+  _oneof_case_[0] = kFp32;
+}
+inline ::substrait::Type_FP32* ParameterizedType::release_fp32() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.fp32)
+  if (_internal_has_fp32()) {
+    clear_has_kind();
+      ::substrait::Type_FP32* temp = kind_.fp32_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.fp32_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_FP32& ParameterizedType::_internal_fp32() const {
+  return _internal_has_fp32()
+      ? *kind_.fp32_
+      : reinterpret_cast< ::substrait::Type_FP32&>(::substrait::_Type_FP32_default_instance_);
+}
+inline const ::substrait::Type_FP32& ParameterizedType::fp32() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.fp32)
+  return _internal_fp32();
+}
+inline ::substrait::Type_FP32* ParameterizedType::unsafe_arena_release_fp32() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.fp32)
+  if (_internal_has_fp32()) {
+    clear_has_kind();
+    ::substrait::Type_FP32* temp = kind_.fp32_;
+    kind_.fp32_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_fp32(::substrait::Type_FP32* fp32) {
+  clear_kind();
+  if (fp32) {
+    set_has_fp32();
+    kind_.fp32_ = fp32;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.fp32)
+}
+inline ::substrait::Type_FP32* ParameterizedType::_internal_mutable_fp32() {
+  if (!_internal_has_fp32()) {
+    clear_kind();
+    set_has_fp32();
+    kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArenaForAllocation());
+  }
+  return kind_.fp32_;
+}
+inline ::substrait::Type_FP32* ParameterizedType::mutable_fp32() {
+  ::substrait::Type_FP32* _msg = _internal_mutable_fp32();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fp32)
+  return _msg;
+}
+
+// .substrait.Type.FP64 fp64 = 11;
+inline bool ParameterizedType::_internal_has_fp64() const {
+  return kind_case() == kFp64;
+}
+inline bool ParameterizedType::has_fp64() const {
+  return _internal_has_fp64();
+}
+inline void ParameterizedType::set_has_fp64() {
+  _oneof_case_[0] = kFp64;
+}
+inline ::substrait::Type_FP64* ParameterizedType::release_fp64() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.fp64)
+  if (_internal_has_fp64()) {
+    clear_has_kind();
+      ::substrait::Type_FP64* temp = kind_.fp64_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.fp64_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_FP64& ParameterizedType::_internal_fp64() const {
+  return _internal_has_fp64()
+      ? *kind_.fp64_
+      : reinterpret_cast< ::substrait::Type_FP64&>(::substrait::_Type_FP64_default_instance_);
+}
+inline const ::substrait::Type_FP64& ParameterizedType::fp64() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.fp64)
+  return _internal_fp64();
+}
+inline ::substrait::Type_FP64* ParameterizedType::unsafe_arena_release_fp64() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.fp64)
+  if (_internal_has_fp64()) {
+    clear_has_kind();
+    ::substrait::Type_FP64* temp = kind_.fp64_;
+    kind_.fp64_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_fp64(::substrait::Type_FP64* fp64) {
+  clear_kind();
+  if (fp64) {
+    set_has_fp64();
+    kind_.fp64_ = fp64;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.fp64)
+}
+inline ::substrait::Type_FP64* ParameterizedType::_internal_mutable_fp64() {
+  if (!_internal_has_fp64()) {
+    clear_kind();
+    set_has_fp64();
+    kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArenaForAllocation());
+  }
+  return kind_.fp64_;
+}
+inline ::substrait::Type_FP64* ParameterizedType::mutable_fp64() {
+  ::substrait::Type_FP64* _msg = _internal_mutable_fp64();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fp64)
+  return _msg;
+}
+
+// .substrait.Type.String string = 12;
+inline bool ParameterizedType::_internal_has_string() const {
+  return kind_case() == kString;
+}
+inline bool ParameterizedType::has_string() const {
+  return _internal_has_string();
+}
+inline void ParameterizedType::set_has_string() {
+  _oneof_case_[0] = kString;
+}
+inline ::substrait::Type_String* ParameterizedType::release_string() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.string)
+  if (_internal_has_string()) {
+    clear_has_kind();
+      ::substrait::Type_String* temp = kind_.string_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.string_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_String& ParameterizedType::_internal_string() const {
+  return _internal_has_string()
+      ? *kind_.string_
+      : reinterpret_cast< ::substrait::Type_String&>(::substrait::_Type_String_default_instance_);
+}
+inline const ::substrait::Type_String& ParameterizedType::string() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.string)
+  return _internal_string();
+}
+inline ::substrait::Type_String* ParameterizedType::unsafe_arena_release_string() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.string)
+  if (_internal_has_string()) {
+    clear_has_kind();
+    ::substrait::Type_String* temp = kind_.string_;
+    kind_.string_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_string(::substrait::Type_String* string) {
+  clear_kind();
+  if (string) {
+    set_has_string();
+    kind_.string_ = string;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.string)
+}
+inline ::substrait::Type_String* ParameterizedType::_internal_mutable_string() {
+  if (!_internal_has_string()) {
+    clear_kind();
+    set_has_string();
+    kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArenaForAllocation());
+  }
+  return kind_.string_;
+}
+inline ::substrait::Type_String* ParameterizedType::mutable_string() {
+  ::substrait::Type_String* _msg = _internal_mutable_string();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.string)
+  return _msg;
+}
+
+// .substrait.Type.Binary binary = 13;
+inline bool ParameterizedType::_internal_has_binary() const {
+  return kind_case() == kBinary;
+}
+inline bool ParameterizedType::has_binary() const {
+  return _internal_has_binary();
+}
+inline void ParameterizedType::set_has_binary() {
+  _oneof_case_[0] = kBinary;
+}
+inline ::substrait::Type_Binary* ParameterizedType::release_binary() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.binary)
+  if (_internal_has_binary()) {
+    clear_has_kind();
+      ::substrait::Type_Binary* temp = kind_.binary_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.binary_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Binary& ParameterizedType::_internal_binary() const {
+  return _internal_has_binary()
+      ? *kind_.binary_
+      : reinterpret_cast< ::substrait::Type_Binary&>(::substrait::_Type_Binary_default_instance_);
+}
+inline const ::substrait::Type_Binary& ParameterizedType::binary() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.binary)
+  return _internal_binary();
+}
+inline ::substrait::Type_Binary* ParameterizedType::unsafe_arena_release_binary() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.binary)
+  if (_internal_has_binary()) {
+    clear_has_kind();
+    ::substrait::Type_Binary* temp = kind_.binary_;
+    kind_.binary_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_binary(::substrait::Type_Binary* binary) {
+  clear_kind();
+  if (binary) {
+    set_has_binary();
+    kind_.binary_ = binary;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.binary)
+}
+inline ::substrait::Type_Binary* ParameterizedType::_internal_mutable_binary() {
+  if (!_internal_has_binary()) {
+    clear_kind();
+    set_has_binary();
+    kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArenaForAllocation());
+  }
+  return kind_.binary_;
+}
+inline ::substrait::Type_Binary* ParameterizedType::mutable_binary() {
+  ::substrait::Type_Binary* _msg = _internal_mutable_binary();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.binary)
+  return _msg;
+}
+
+// .substrait.Type.Timestamp timestamp = 14;
+inline bool ParameterizedType::_internal_has_timestamp() const {
+  return kind_case() == kTimestamp;
+}
+inline bool ParameterizedType::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void ParameterizedType::set_has_timestamp() {
+  _oneof_case_[0] = kTimestamp;
+}
+inline ::substrait::Type_Timestamp* ParameterizedType::release_timestamp() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.timestamp)
+  if (_internal_has_timestamp()) {
+    clear_has_kind();
+      ::substrait::Type_Timestamp* temp = kind_.timestamp_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.timestamp_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Timestamp& ParameterizedType::_internal_timestamp() const {
+  return _internal_has_timestamp()
+      ? *kind_.timestamp_
+      : reinterpret_cast< ::substrait::Type_Timestamp&>(::substrait::_Type_Timestamp_default_instance_);
+}
+inline const ::substrait::Type_Timestamp& ParameterizedType::timestamp() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.timestamp)
+  return _internal_timestamp();
+}
+inline ::substrait::Type_Timestamp* ParameterizedType::unsafe_arena_release_timestamp() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.timestamp)
+  if (_internal_has_timestamp()) {
+    clear_has_kind();
+    ::substrait::Type_Timestamp* temp = kind_.timestamp_;
+    kind_.timestamp_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) {
+  clear_kind();
+  if (timestamp) {
+    set_has_timestamp();
+    kind_.timestamp_ = timestamp;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.timestamp)
+}
+inline ::substrait::Type_Timestamp* ParameterizedType::_internal_mutable_timestamp() {
+  if (!_internal_has_timestamp()) {
+    clear_kind();
+    set_has_timestamp();
+    kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArenaForAllocation());
+  }
+  return kind_.timestamp_;
+}
+inline ::substrait::Type_Timestamp* ParameterizedType::mutable_timestamp() {
+  ::substrait::Type_Timestamp* _msg = _internal_mutable_timestamp();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.timestamp)
+  return _msg;
+}
+
+// .substrait.Type.Date date = 16;
+inline bool ParameterizedType::_internal_has_date() const {
+  return kind_case() == kDate;
+}
+inline bool ParameterizedType::has_date() const {
+  return _internal_has_date();
+}
+inline void ParameterizedType::set_has_date() {
+  _oneof_case_[0] = kDate;
+}
+inline ::substrait::Type_Date* ParameterizedType::release_date() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.date)
+  if (_internal_has_date()) {
+    clear_has_kind();
+      ::substrait::Type_Date* temp = kind_.date_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.date_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Date& ParameterizedType::_internal_date() const {
+  return _internal_has_date()
+      ? *kind_.date_
+      : reinterpret_cast< ::substrait::Type_Date&>(::substrait::_Type_Date_default_instance_);
+}
+inline const ::substrait::Type_Date& ParameterizedType::date() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.date)
+  return _internal_date();
+}
+inline ::substrait::Type_Date* ParameterizedType::unsafe_arena_release_date() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.date)
+  if (_internal_has_date()) {
+    clear_has_kind();
+    ::substrait::Type_Date* temp = kind_.date_;
+    kind_.date_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_date(::substrait::Type_Date* date) {
+  clear_kind();
+  if (date) {
+    set_has_date();
+    kind_.date_ = date;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.date)
+}
+inline ::substrait::Type_Date* ParameterizedType::_internal_mutable_date() {
+  if (!_internal_has_date()) {
+    clear_kind();
+    set_has_date();
+    kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArenaForAllocation());
+  }
+  return kind_.date_;
+}
+inline ::substrait::Type_Date* ParameterizedType::mutable_date() {
+  ::substrait::Type_Date* _msg = _internal_mutable_date();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.date)
+  return _msg;
+}
+
+// .substrait.Type.Time time = 17;
+inline bool ParameterizedType::_internal_has_time() const {
+  return kind_case() == kTime;
+}
+inline bool ParameterizedType::has_time() const {
+  return _internal_has_time();
+}
+inline void ParameterizedType::set_has_time() {
+  _oneof_case_[0] = kTime;
+}
+inline ::substrait::Type_Time* ParameterizedType::release_time() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.time)
+  if (_internal_has_time()) {
+    clear_has_kind();
+      ::substrait::Type_Time* temp = kind_.time_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.time_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Time& ParameterizedType::_internal_time() const {
+  return _internal_has_time()
+      ? *kind_.time_
+      : reinterpret_cast< ::substrait::Type_Time&>(::substrait::_Type_Time_default_instance_);
+}
+inline const ::substrait::Type_Time& ParameterizedType::time() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.time)
+  return _internal_time();
+}
+inline ::substrait::Type_Time* ParameterizedType::unsafe_arena_release_time() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.time)
+  if (_internal_has_time()) {
+    clear_has_kind();
+    ::substrait::Type_Time* temp = kind_.time_;
+    kind_.time_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_time(::substrait::Type_Time* time) {
+  clear_kind();
+  if (time) {
+    set_has_time();
+    kind_.time_ = time;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.time)
+}
+inline ::substrait::Type_Time* ParameterizedType::_internal_mutable_time() {
+  if (!_internal_has_time()) {
+    clear_kind();
+    set_has_time();
+    kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArenaForAllocation());
+  }
+  return kind_.time_;
+}
+inline ::substrait::Type_Time* ParameterizedType::mutable_time() {
+  ::substrait::Type_Time* _msg = _internal_mutable_time();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.time)
+  return _msg;
+}
+
+// .substrait.Type.IntervalYear interval_year = 19;
+inline bool ParameterizedType::_internal_has_interval_year() const {
+  return kind_case() == kIntervalYear;
+}
+inline bool ParameterizedType::has_interval_year() const {
+  return _internal_has_interval_year();
+}
+inline void ParameterizedType::set_has_interval_year() {
+  _oneof_case_[0] = kIntervalYear;
+}
+inline ::substrait::Type_IntervalYear* ParameterizedType::release_interval_year() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.interval_year)
+  if (_internal_has_interval_year()) {
+    clear_has_kind();
+      ::substrait::Type_IntervalYear* temp = kind_.interval_year_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.interval_year_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_IntervalYear& ParameterizedType::_internal_interval_year() const {
+  return _internal_has_interval_year()
+      ? *kind_.interval_year_
+      : reinterpret_cast< ::substrait::Type_IntervalYear&>(::substrait::_Type_IntervalYear_default_instance_);
+}
+inline const ::substrait::Type_IntervalYear& ParameterizedType::interval_year() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.interval_year)
+  return _internal_interval_year();
+}
+inline ::substrait::Type_IntervalYear* ParameterizedType::unsafe_arena_release_interval_year() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.interval_year)
+  if (_internal_has_interval_year()) {
+    clear_has_kind();
+    ::substrait::Type_IntervalYear* temp = kind_.interval_year_;
+    kind_.interval_year_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) {
+  clear_kind();
+  if (interval_year) {
+    set_has_interval_year();
+    kind_.interval_year_ = interval_year;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.interval_year)
+}
+inline ::substrait::Type_IntervalYear* ParameterizedType::_internal_mutable_interval_year() {
+  if (!_internal_has_interval_year()) {
+    clear_kind();
+    set_has_interval_year();
+    kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArenaForAllocation());
+  }
+  return kind_.interval_year_;
+}
+inline ::substrait::Type_IntervalYear* ParameterizedType::mutable_interval_year() {
+  ::substrait::Type_IntervalYear* _msg = _internal_mutable_interval_year();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.interval_year)
+  return _msg;
+}
+
+// .substrait.Type.IntervalDay interval_day = 20;
+inline bool ParameterizedType::_internal_has_interval_day() const {
+  return kind_case() == kIntervalDay;
+}
+inline bool ParameterizedType::has_interval_day() const {
+  return _internal_has_interval_day();
+}
+inline void ParameterizedType::set_has_interval_day() {
+  _oneof_case_[0] = kIntervalDay;
+}
+inline ::substrait::Type_IntervalDay* ParameterizedType::release_interval_day() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.interval_day)
+  if (_internal_has_interval_day()) {
+    clear_has_kind();
+      ::substrait::Type_IntervalDay* temp = kind_.interval_day_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.interval_day_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_IntervalDay& ParameterizedType::_internal_interval_day() const {
+  return _internal_has_interval_day()
+      ? *kind_.interval_day_
+      : reinterpret_cast< ::substrait::Type_IntervalDay&>(::substrait::_Type_IntervalDay_default_instance_);
+}
+inline const ::substrait::Type_IntervalDay& ParameterizedType::interval_day() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.interval_day)
+  return _internal_interval_day();
+}
+inline ::substrait::Type_IntervalDay* ParameterizedType::unsafe_arena_release_interval_day() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.interval_day)
+  if (_internal_has_interval_day()) {
+    clear_has_kind();
+    ::substrait::Type_IntervalDay* temp = kind_.interval_day_;
+    kind_.interval_day_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) {
+  clear_kind();
+  if (interval_day) {
+    set_has_interval_day();
+    kind_.interval_day_ = interval_day;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.interval_day)
+}
+inline ::substrait::Type_IntervalDay* ParameterizedType::_internal_mutable_interval_day() {
+  if (!_internal_has_interval_day()) {
+    clear_kind();
+    set_has_interval_day();
+    kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArenaForAllocation());
+  }
+  return kind_.interval_day_;
+}
+inline ::substrait::Type_IntervalDay* ParameterizedType::mutable_interval_day() {
+  ::substrait::Type_IntervalDay* _msg = _internal_mutable_interval_day();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.interval_day)
+  return _msg;
+}
+
+// .substrait.Type.TimestampTZ timestamp_tz = 29;
+inline bool ParameterizedType::_internal_has_timestamp_tz() const {
+  return kind_case() == kTimestampTz;
+}
+inline bool ParameterizedType::has_timestamp_tz() const {
+  return _internal_has_timestamp_tz();
+}
+inline void ParameterizedType::set_has_timestamp_tz() {
+  _oneof_case_[0] = kTimestampTz;
+}
+inline ::substrait::Type_TimestampTZ* ParameterizedType::release_timestamp_tz() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.timestamp_tz)
+  if (_internal_has_timestamp_tz()) {
+    clear_has_kind();
+      ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.timestamp_tz_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_TimestampTZ& ParameterizedType::_internal_timestamp_tz() const {
+  return _internal_has_timestamp_tz()
+      ? *kind_.timestamp_tz_
+      : reinterpret_cast< ::substrait::Type_TimestampTZ&>(::substrait::_Type_TimestampTZ_default_instance_);
+}
+inline const ::substrait::Type_TimestampTZ& ParameterizedType::timestamp_tz() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.timestamp_tz)
+  return _internal_timestamp_tz();
+}
+inline ::substrait::Type_TimestampTZ* ParameterizedType::unsafe_arena_release_timestamp_tz() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.timestamp_tz)
+  if (_internal_has_timestamp_tz()) {
+    clear_has_kind();
+    ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_;
+    kind_.timestamp_tz_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) {
+  clear_kind();
+  if (timestamp_tz) {
+    set_has_timestamp_tz();
+    kind_.timestamp_tz_ = timestamp_tz;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.timestamp_tz)
+}
+inline ::substrait::Type_TimestampTZ* ParameterizedType::_internal_mutable_timestamp_tz() {
+  if (!_internal_has_timestamp_tz()) {
+    clear_kind();
+    set_has_timestamp_tz();
+    kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArenaForAllocation());
+  }
+  return kind_.timestamp_tz_;
+}
+inline ::substrait::Type_TimestampTZ* ParameterizedType::mutable_timestamp_tz() {
+  ::substrait::Type_TimestampTZ* _msg = _internal_mutable_timestamp_tz();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.timestamp_tz)
+  return _msg;
+}
+
+// .substrait.Type.UUID uuid = 32;
+inline bool ParameterizedType::_internal_has_uuid() const {
+  return kind_case() == kUuid;
+}
+inline bool ParameterizedType::has_uuid() const {
+  return _internal_has_uuid();
+}
+inline void ParameterizedType::set_has_uuid() {
+  _oneof_case_[0] = kUuid;
+}
+inline ::substrait::Type_UUID* ParameterizedType::release_uuid() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.uuid)
+  if (_internal_has_uuid()) {
+    clear_has_kind();
+      ::substrait::Type_UUID* temp = kind_.uuid_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.uuid_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_UUID& ParameterizedType::_internal_uuid() const {
+  return _internal_has_uuid()
+      ? *kind_.uuid_
+      : reinterpret_cast< ::substrait::Type_UUID&>(::substrait::_Type_UUID_default_instance_);
+}
+inline const ::substrait::Type_UUID& ParameterizedType::uuid() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.uuid)
+  return _internal_uuid();
+}
+inline ::substrait::Type_UUID* ParameterizedType::unsafe_arena_release_uuid() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.uuid)
+  if (_internal_has_uuid()) {
+    clear_has_kind();
+    ::substrait::Type_UUID* temp = kind_.uuid_;
+    kind_.uuid_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_uuid(::substrait::Type_UUID* uuid) {
+  clear_kind();
+  if (uuid) {
+    set_has_uuid();
+    kind_.uuid_ = uuid;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.uuid)
+}
+inline ::substrait::Type_UUID* ParameterizedType::_internal_mutable_uuid() {
+  if (!_internal_has_uuid()) {
+    clear_kind();
+    set_has_uuid();
+    kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArenaForAllocation());
+  }
+  return kind_.uuid_;
+}
+inline ::substrait::Type_UUID* ParameterizedType::mutable_uuid() {
+  ::substrait::Type_UUID* _msg = _internal_mutable_uuid();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.uuid)
+  return _msg;
+}
+
+// .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21;
+inline bool ParameterizedType::_internal_has_fixed_char() const {
+  return kind_case() == kFixedChar;
+}
+inline bool ParameterizedType::has_fixed_char() const {
+  return _internal_has_fixed_char();
+}
+inline void ParameterizedType::set_has_fixed_char() {
+  _oneof_case_[0] = kFixedChar;
+}
+inline void ParameterizedType::clear_fixed_char() {
+  if (_internal_has_fixed_char()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.fixed_char_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::release_fixed_char() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.fixed_char)
+  if (_internal_has_fixed_char()) {
+    clear_has_kind();
+      ::substrait::ParameterizedType_ParameterizedFixedChar* temp = kind_.fixed_char_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.fixed_char_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ParameterizedType_ParameterizedFixedChar& ParameterizedType::_internal_fixed_char() const {
+  return _internal_has_fixed_char()
+      ? *kind_.fixed_char_
+      : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedFixedChar&>(::substrait::_ParameterizedType_ParameterizedFixedChar_default_instance_);
+}
+inline const ::substrait::ParameterizedType_ParameterizedFixedChar& ParameterizedType::fixed_char() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.fixed_char)
+  return _internal_fixed_char();
+}
+inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::unsafe_arena_release_fixed_char() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.fixed_char)
+  if (_internal_has_fixed_char()) {
+    clear_has_kind();
+    ::substrait::ParameterizedType_ParameterizedFixedChar* temp = kind_.fixed_char_;
+    kind_.fixed_char_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_fixed_char(::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char) {
+  clear_kind();
+  if (fixed_char) {
+    set_has_fixed_char();
+    kind_.fixed_char_ = fixed_char;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.fixed_char)
+}
+inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::_internal_mutable_fixed_char() {
+  if (!_internal_has_fixed_char()) {
+    clear_kind();
+    set_has_fixed_char();
+    kind_.fixed_char_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedChar >(GetArenaForAllocation());
+  }
+  return kind_.fixed_char_;
+}
+inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::mutable_fixed_char() {
+  ::substrait::ParameterizedType_ParameterizedFixedChar* _msg = _internal_mutable_fixed_char();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fixed_char)
+  return _msg;
+}
+
+// .substrait.ParameterizedType.ParameterizedVarChar varchar = 22;
+inline bool ParameterizedType::_internal_has_varchar() const {
+  return kind_case() == kVarchar;
+}
+inline bool ParameterizedType::has_varchar() const {
+  return _internal_has_varchar();
+}
+inline void ParameterizedType::set_has_varchar() {
+  _oneof_case_[0] = kVarchar;
+}
+inline void ParameterizedType::clear_varchar() {
+  if (_internal_has_varchar()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.varchar_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::release_varchar() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.varchar)
+  if (_internal_has_varchar()) {
+    clear_has_kind();
+      ::substrait::ParameterizedType_ParameterizedVarChar* temp = kind_.varchar_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.varchar_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ParameterizedType_ParameterizedVarChar& ParameterizedType::_internal_varchar() const {
+  return _internal_has_varchar()
+      ? *kind_.varchar_
+      : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedVarChar&>(::substrait::_ParameterizedType_ParameterizedVarChar_default_instance_);
+}
+inline const ::substrait::ParameterizedType_ParameterizedVarChar& ParameterizedType::varchar() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.varchar)
+  return _internal_varchar();
+}
+inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::unsafe_arena_release_varchar() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.varchar)
+  if (_internal_has_varchar()) {
+    clear_has_kind();
+    ::substrait::ParameterizedType_ParameterizedVarChar* temp = kind_.varchar_;
+    kind_.varchar_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_varchar(::substrait::ParameterizedType_ParameterizedVarChar* varchar) {
+  clear_kind();
+  if (varchar) {
+    set_has_varchar();
+    kind_.varchar_ = varchar;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.varchar)
+}
+inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::_internal_mutable_varchar() {
+  if (!_internal_has_varchar()) {
+    clear_kind();
+    set_has_varchar();
+    kind_.varchar_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedVarChar >(GetArenaForAllocation());
+  }
+  return kind_.varchar_;
+}
+inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::mutable_varchar() {
+  ::substrait::ParameterizedType_ParameterizedVarChar* _msg = _internal_mutable_varchar();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.varchar)
+  return _msg;
+}
+
+// .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23;
+inline bool ParameterizedType::_internal_has_fixed_binary() const {
+  return kind_case() == kFixedBinary;
+}
+inline bool ParameterizedType::has_fixed_binary() const {
+  return _internal_has_fixed_binary();
+}
+inline void ParameterizedType::set_has_fixed_binary() {
+  _oneof_case_[0] = kFixedBinary;
+}
+inline void ParameterizedType::clear_fixed_binary() {
+  if (_internal_has_fixed_binary()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.fixed_binary_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::release_fixed_binary() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.fixed_binary)
+  if (_internal_has_fixed_binary()) {
+    clear_has_kind();
+      ::substrait::ParameterizedType_ParameterizedFixedBinary* temp = kind_.fixed_binary_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.fixed_binary_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ParameterizedType_ParameterizedFixedBinary& ParameterizedType::_internal_fixed_binary() const {
+  return _internal_has_fixed_binary()
+      ? *kind_.fixed_binary_
+      : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedFixedBinary&>(::substrait::_ParameterizedType_ParameterizedFixedBinary_default_instance_);
+}
+inline const ::substrait::ParameterizedType_ParameterizedFixedBinary& ParameterizedType::fixed_binary() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.fixed_binary)
+  return _internal_fixed_binary();
+}
+inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::unsafe_arena_release_fixed_binary() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.fixed_binary)
+  if (_internal_has_fixed_binary()) {
+    clear_has_kind();
+    ::substrait::ParameterizedType_ParameterizedFixedBinary* temp = kind_.fixed_binary_;
+    kind_.fixed_binary_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_fixed_binary(::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary) {
+  clear_kind();
+  if (fixed_binary) {
+    set_has_fixed_binary();
+    kind_.fixed_binary_ = fixed_binary;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.fixed_binary)
+}
+inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::_internal_mutable_fixed_binary() {
+  if (!_internal_has_fixed_binary()) {
+    clear_kind();
+    set_has_fixed_binary();
+    kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedBinary >(GetArenaForAllocation());
+  }
+  return kind_.fixed_binary_;
+}
+inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::mutable_fixed_binary() {
+  ::substrait::ParameterizedType_ParameterizedFixedBinary* _msg = _internal_mutable_fixed_binary();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fixed_binary)
+  return _msg;
+}
+
+// .substrait.ParameterizedType.ParameterizedDecimal decimal = 24;
+inline bool ParameterizedType::_internal_has_decimal() const {
+  return kind_case() == kDecimal;
+}
+inline bool ParameterizedType::has_decimal() const {
+  return _internal_has_decimal();
+}
+inline void ParameterizedType::set_has_decimal() {
+  _oneof_case_[0] = kDecimal;
+}
+inline void ParameterizedType::clear_decimal() {
+  if (_internal_has_decimal()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.decimal_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::release_decimal() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.decimal)
+  if (_internal_has_decimal()) {
+    clear_has_kind();
+      ::substrait::ParameterizedType_ParameterizedDecimal* temp = kind_.decimal_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.decimal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ParameterizedType_ParameterizedDecimal& ParameterizedType::_internal_decimal() const {
+  return _internal_has_decimal()
+      ? *kind_.decimal_
+      : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedDecimal&>(::substrait::_ParameterizedType_ParameterizedDecimal_default_instance_);
+}
+inline const ::substrait::ParameterizedType_ParameterizedDecimal& ParameterizedType::decimal() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.decimal)
+  return _internal_decimal();
+}
+inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::unsafe_arena_release_decimal() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.decimal)
+  if (_internal_has_decimal()) {
+    clear_has_kind();
+    ::substrait::ParameterizedType_ParameterizedDecimal* temp = kind_.decimal_;
+    kind_.decimal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_decimal(::substrait::ParameterizedType_ParameterizedDecimal* decimal) {
+  clear_kind();
+  if (decimal) {
+    set_has_decimal();
+    kind_.decimal_ = decimal;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.decimal)
+}
+inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::_internal_mutable_decimal() {
+  if (!_internal_has_decimal()) {
+    clear_kind();
+    set_has_decimal();
+    kind_.decimal_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedDecimal >(GetArenaForAllocation());
+  }
+  return kind_.decimal_;
+}
+inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::mutable_decimal() {
+  ::substrait::ParameterizedType_ParameterizedDecimal* _msg = _internal_mutable_decimal();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.decimal)
+  return _msg;
+}
+
+// .substrait.ParameterizedType.ParameterizedStruct struct = 25;
+inline bool ParameterizedType::_internal_has_struct_() const {
+  return kind_case() == kStruct;
+}
+inline bool ParameterizedType::has_struct_() const {
+  return _internal_has_struct_();
+}
+inline void ParameterizedType::set_has_struct_() {
+  _oneof_case_[0] = kStruct;
+}
+inline void ParameterizedType::clear_struct_() {
+  if (_internal_has_struct_()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.struct__;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::release_struct_() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.struct)
+  if (_internal_has_struct_()) {
+    clear_has_kind();
+      ::substrait::ParameterizedType_ParameterizedStruct* temp = kind_.struct__;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.struct__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType::_internal_struct_() const {
+  return _internal_has_struct_()
+      ? *kind_.struct__
+      : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedStruct&>(::substrait::_ParameterizedType_ParameterizedStruct_default_instance_);
+}
+inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType::struct_() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.struct)
+  return _internal_struct_();
+}
+inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::unsafe_arena_release_struct_() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.struct)
+  if (_internal_has_struct_()) {
+    clear_has_kind();
+    ::substrait::ParameterizedType_ParameterizedStruct* temp = kind_.struct__;
+    kind_.struct__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_) {
+  clear_kind();
+  if (struct_) {
+    set_has_struct_();
+    kind_.struct__ = struct_;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.struct)
+}
+inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::_internal_mutable_struct_() {
+  if (!_internal_has_struct_()) {
+    clear_kind();
+    set_has_struct_();
+    kind_.struct__ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedStruct >(GetArenaForAllocation());
+  }
+  return kind_.struct__;
+}
+inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::mutable_struct_() {
+  ::substrait::ParameterizedType_ParameterizedStruct* _msg = _internal_mutable_struct_();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.struct)
+  return _msg;
+}
+
+// .substrait.ParameterizedType.ParameterizedList list = 27;
+inline bool ParameterizedType::_internal_has_list() const {
+  return kind_case() == kList;
+}
+inline bool ParameterizedType::has_list() const {
+  return _internal_has_list();
+}
+inline void ParameterizedType::set_has_list() {
+  _oneof_case_[0] = kList;
+}
+inline void ParameterizedType::clear_list() {
+  if (_internal_has_list()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.list_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::release_list() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.list)
+  if (_internal_has_list()) {
+    clear_has_kind();
+      ::substrait::ParameterizedType_ParameterizedList* temp = kind_.list_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ParameterizedType_ParameterizedList& ParameterizedType::_internal_list() const {
+  return _internal_has_list()
+      ? *kind_.list_
+      : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedList&>(::substrait::_ParameterizedType_ParameterizedList_default_instance_);
+}
+inline const ::substrait::ParameterizedType_ParameterizedList& ParameterizedType::list() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.list)
+  return _internal_list();
+}
+inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::unsafe_arena_release_list() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.list)
+  if (_internal_has_list()) {
+    clear_has_kind();
+    ::substrait::ParameterizedType_ParameterizedList* temp = kind_.list_;
+    kind_.list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_list(::substrait::ParameterizedType_ParameterizedList* list) {
+  clear_kind();
+  if (list) {
+    set_has_list();
+    kind_.list_ = list;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.list)
+}
+inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::_internal_mutable_list() {
+  if (!_internal_has_list()) {
+    clear_kind();
+    set_has_list();
+    kind_.list_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedList >(GetArenaForAllocation());
+  }
+  return kind_.list_;
+}
+inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::mutable_list() {
+  ::substrait::ParameterizedType_ParameterizedList* _msg = _internal_mutable_list();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.list)
+  return _msg;
+}
+
+// .substrait.ParameterizedType.ParameterizedMap map = 28;
+inline bool ParameterizedType::_internal_has_map() const {
+  return kind_case() == kMap;
+}
+inline bool ParameterizedType::has_map() const {
+  return _internal_has_map();
+}
+inline void ParameterizedType::set_has_map() {
+  _oneof_case_[0] = kMap;
+}
+inline void ParameterizedType::clear_map() {
+  if (_internal_has_map()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.map_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::release_map() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.map)
+  if (_internal_has_map()) {
+    clear_has_kind();
+      ::substrait::ParameterizedType_ParameterizedMap* temp = kind_.map_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.map_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ParameterizedType_ParameterizedMap& ParameterizedType::_internal_map() const {
+  return _internal_has_map()
+      ? *kind_.map_
+      : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedMap&>(::substrait::_ParameterizedType_ParameterizedMap_default_instance_);
+}
+inline const ::substrait::ParameterizedType_ParameterizedMap& ParameterizedType::map() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.map)
+  return _internal_map();
+}
+inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::unsafe_arena_release_map() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.map)
+  if (_internal_has_map()) {
+    clear_has_kind();
+    ::substrait::ParameterizedType_ParameterizedMap* temp = kind_.map_;
+    kind_.map_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_map(::substrait::ParameterizedType_ParameterizedMap* map) {
+  clear_kind();
+  if (map) {
+    set_has_map();
+    kind_.map_ = map;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.map)
+}
+inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::_internal_mutable_map() {
+  if (!_internal_has_map()) {
+    clear_kind();
+    set_has_map();
+    kind_.map_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedMap >(GetArenaForAllocation());
+  }
+  return kind_.map_;
+}
+inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::mutable_map() {
+  ::substrait::ParameterizedType_ParameterizedMap* _msg = _internal_mutable_map();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.map)
+  return _msg;
+}
+
+// uint32 user_defined_pointer = 31;
+inline bool ParameterizedType::_internal_has_user_defined_pointer() const {
+  return kind_case() == kUserDefinedPointer;
+}
+inline bool ParameterizedType::has_user_defined_pointer() const {
+  return _internal_has_user_defined_pointer();
+}
+inline void ParameterizedType::set_has_user_defined_pointer() {
+  _oneof_case_[0] = kUserDefinedPointer;
+}
+inline void ParameterizedType::clear_user_defined_pointer() {
+  if (_internal_has_user_defined_pointer()) {
+    kind_.user_defined_pointer_ = 0u;
+    clear_has_kind();
+  }
+}
+inline uint32_t ParameterizedType::_internal_user_defined_pointer() const {
+  if (_internal_has_user_defined_pointer()) {
+    return kind_.user_defined_pointer_;
+  }
+  return 0u;
+}
+inline void ParameterizedType::_internal_set_user_defined_pointer(uint32_t value) {
+  if (!_internal_has_user_defined_pointer()) {
+    clear_kind();
+    set_has_user_defined_pointer();
+  }
+  kind_.user_defined_pointer_ = value;
+}
+inline uint32_t ParameterizedType::user_defined_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.user_defined_pointer)
+  return _internal_user_defined_pointer();
+}
+inline void ParameterizedType::set_user_defined_pointer(uint32_t value) {
+  _internal_set_user_defined_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.ParameterizedType.user_defined_pointer)
+}
+
+// .substrait.ParameterizedType.TypeParameter type_parameter = 33;
+inline bool ParameterizedType::_internal_has_type_parameter() const {
+  return kind_case() == kTypeParameter;
+}
+inline bool ParameterizedType::has_type_parameter() const {
+  return _internal_has_type_parameter();
+}
+inline void ParameterizedType::set_has_type_parameter() {
+  _oneof_case_[0] = kTypeParameter;
+}
+inline void ParameterizedType::clear_type_parameter() {
+  if (_internal_has_type_parameter()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.type_parameter_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::release_type_parameter() {
+  // @@protoc_insertion_point(field_release:substrait.ParameterizedType.type_parameter)
+  if (_internal_has_type_parameter()) {
+    clear_has_kind();
+      ::substrait::ParameterizedType_TypeParameter* temp = kind_.type_parameter_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.type_parameter_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ParameterizedType_TypeParameter& ParameterizedType::_internal_type_parameter() const {
+  return _internal_has_type_parameter()
+      ? *kind_.type_parameter_
+      : reinterpret_cast< ::substrait::ParameterizedType_TypeParameter&>(::substrait::_ParameterizedType_TypeParameter_default_instance_);
+}
+inline const ::substrait::ParameterizedType_TypeParameter& ParameterizedType::type_parameter() const {
+  // @@protoc_insertion_point(field_get:substrait.ParameterizedType.type_parameter)
+  return _internal_type_parameter();
+}
+inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::unsafe_arena_release_type_parameter() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.type_parameter)
+  if (_internal_has_type_parameter()) {
+    clear_has_kind();
+    ::substrait::ParameterizedType_TypeParameter* temp = kind_.type_parameter_;
+    kind_.type_parameter_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ParameterizedType::unsafe_arena_set_allocated_type_parameter(::substrait::ParameterizedType_TypeParameter* type_parameter) {
+  clear_kind();
+  if (type_parameter) {
+    set_has_type_parameter();
+    kind_.type_parameter_ = type_parameter;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.type_parameter)
+}
+inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::_internal_mutable_type_parameter() {
+  if (!_internal_has_type_parameter()) {
+    clear_kind();
+    set_has_type_parameter();
+    kind_.type_parameter_ = CreateMaybeMessage< ::substrait::ParameterizedType_TypeParameter >(GetArenaForAllocation());
+  }
+  return kind_.type_parameter_;
+}
+inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::mutable_type_parameter() {
+  ::substrait::ParameterizedType_TypeParameter* _msg = _internal_mutable_type_parameter();
+  // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.type_parameter)
+  return _msg;
+}
+
+inline bool ParameterizedType::has_kind() const {
+  return kind_case() != KIND_NOT_SET;
+}
+inline void ParameterizedType::clear_has_kind() {
+  _oneof_case_[0] = KIND_NOT_SET;
+}
+inline ParameterizedType::KindCase ParameterizedType::kind_case() const {
+  return ParameterizedType::KindCase(_oneof_case_[0]);
+}
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace substrait
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fparameterized_5ftypes_2eproto
diff --git a/cpp/src/generated/substrait/plan.pb.cc b/cpp/src/generated/substrait/plan.pb.cc
new file mode 100644
index 000000000000..4b77e56bfbd0
--- /dev/null
+++ b/cpp/src/generated/substrait/plan.pb.cc
@@ -0,0 +1,796 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/plan.proto
+
+#include "substrait/plan.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace substrait {
+constexpr PlanRel::PlanRel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct PlanRelDefaultTypeInternal {
+  constexpr PlanRelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~PlanRelDefaultTypeInternal() {}
+  union {
+    PlanRel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PlanRelDefaultTypeInternal _PlanRel_default_instance_;
+constexpr Plan::Plan(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : extension_uris_()
+  , extensions_()
+  , relations_()
+  , expected_type_urls_()
+  , advanced_extensions_(nullptr){}
+struct PlanDefaultTypeInternal {
+  constexpr PlanDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~PlanDefaultTypeInternal() {}
+  union {
+    Plan _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PlanDefaultTypeInternal _Plan_default_instance_;
+}  // namespace substrait
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fplan_2eproto[2];
+static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fplan_2eproto = nullptr;
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fplan_2eproto = nullptr;
+
+const uint32_t TableStruct_substrait_2fplan_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::PlanRel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::PlanRel, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::PlanRel, rel_type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Plan, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Plan, extension_uris_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Plan, extensions_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Plan, relations_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Plan, advanced_extensions_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Plan, expected_type_urls_),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, -1, sizeof(::substrait::PlanRel)},
+  { 9, -1, -1, sizeof(::substrait::Plan)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_PlanRel_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Plan_default_instance_),
+};
+
+const char descriptor_table_protodef_substrait_2fplan_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\024substrait/plan.proto\022\tsubstrait\032\031subst"
+  "rait/relations.proto\032%substrait/extensio"
+  "ns/extensions.proto\"X\n\007PlanRel\022\035\n\003rel\030\001 "
+  "\001(\0132\016.substrait.RelH\000\022\"\n\004root\030\002 \001(\0132\022.su"
+  "bstrait.RelRootH\000B\n\n\010rel_type\"\227\002\n\004Plan\022@"
+  "\n\016extension_uris\030\001 \003(\0132(.substrait.exten"
+  "sions.SimpleExtensionURI\022D\n\nextensions\030\002"
+  " \003(\01320.substrait.extensions.SimpleExtens"
+  "ionDeclaration\022%\n\trelations\030\003 \003(\0132\022.subs"
+  "trait.PlanRel\022D\n\023advanced_extensions\030\004 \001"
+  "(\0132\'.substrait.extensions.AdvancedExtens"
+  "ion\022\032\n\022expected_type_urls\030\005 \003(\tB+\n\022io.su"
+  "bstrait.protoP\001\252\002\022Substrait.Protobufb\006pr"
+  "oto3"
+  ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2fplan_2eproto_deps[2] = {
+  &::descriptor_table_substrait_2fextensions_2fextensions_2eproto,
+  &::descriptor_table_substrait_2frelations_2eproto,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fplan_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fplan_2eproto = {
+  false, false, 524, descriptor_table_protodef_substrait_2fplan_2eproto, "substrait/plan.proto", 
+  &descriptor_table_substrait_2fplan_2eproto_once, descriptor_table_substrait_2fplan_2eproto_deps, 2, 2,
+  schemas, file_default_instances, TableStruct_substrait_2fplan_2eproto::offsets,
+  file_level_metadata_substrait_2fplan_2eproto, file_level_enum_descriptors_substrait_2fplan_2eproto, file_level_service_descriptors_substrait_2fplan_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fplan_2eproto_getter() {
+  return &descriptor_table_substrait_2fplan_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fplan_2eproto(&descriptor_table_substrait_2fplan_2eproto);
+namespace substrait {
+
+// ===================================================================
+
+class PlanRel::_Internal {
+ public:
+  static const ::substrait::Rel& rel(const PlanRel* msg);
+  static const ::substrait::RelRoot& root(const PlanRel* msg);
+};
+
+const ::substrait::Rel&
+PlanRel::_Internal::rel(const PlanRel* msg) {
+  return *msg->rel_type_.rel_;
+}
+const ::substrait::RelRoot&
+PlanRel::_Internal::root(const PlanRel* msg) {
+  return *msg->rel_type_.root_;
+}
+void PlanRel::set_allocated_rel(::substrait::Rel* rel) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (rel) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rel));
+    if (message_arena != submessage_arena) {
+      rel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, rel, submessage_arena);
+    }
+    set_has_rel();
+    rel_type_.rel_ = rel;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.PlanRel.rel)
+}
+void PlanRel::clear_rel() {
+  if (_internal_has_rel()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.rel_;
+    }
+    clear_has_rel_type();
+  }
+}
+void PlanRel::set_allocated_root(::substrait::RelRoot* root) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (root) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(root));
+    if (message_arena != submessage_arena) {
+      root = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, root, submessage_arena);
+    }
+    set_has_root();
+    rel_type_.root_ = root;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.PlanRel.root)
+}
+void PlanRel::clear_root() {
+  if (_internal_has_root()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.root_;
+    }
+    clear_has_rel_type();
+  }
+}
+PlanRel::PlanRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.PlanRel)
+}
+PlanRel::PlanRel(const PlanRel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_rel_type();
+  switch (from.rel_type_case()) {
+    case kRel: {
+      _internal_mutable_rel()->::substrait::Rel::MergeFrom(from._internal_rel());
+      break;
+    }
+    case kRoot: {
+      _internal_mutable_root()->::substrait::RelRoot::MergeFrom(from._internal_root());
+      break;
+    }
+    case REL_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.PlanRel)
+}
+
+inline void PlanRel::SharedCtor() {
+clear_has_rel_type();
+}
+
+PlanRel::~PlanRel() {
+  // @@protoc_insertion_point(destructor:substrait.PlanRel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void PlanRel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_rel_type()) {
+    clear_rel_type();
+  }
+}
+
+void PlanRel::ArenaDtor(void* object) {
+  PlanRel* _this = reinterpret_cast< PlanRel* >(object);
+  (void)_this;
+}
+void PlanRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void PlanRel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void PlanRel::clear_rel_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.PlanRel)
+  switch (rel_type_case()) {
+    case kRel: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.rel_;
+      }
+      break;
+    }
+    case kRoot: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.root_;
+      }
+      break;
+    }
+    case REL_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = REL_TYPE_NOT_SET;
+}
+
+
+void PlanRel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.PlanRel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_rel_type();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* PlanRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Rel rel = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_rel(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.RelRoot root = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_root(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* PlanRel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.PlanRel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Rel rel = 1;
+  if (_internal_has_rel()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::rel(this), target, stream);
+  }
+
+  // .substrait.RelRoot root = 2;
+  if (_internal_has_root()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::root(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.PlanRel)
+  return target;
+}
+
+size_t PlanRel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.PlanRel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (rel_type_case()) {
+    // .substrait.Rel rel = 1;
+    case kRel: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.rel_);
+      break;
+    }
+    // .substrait.RelRoot root = 2;
+    case kRoot: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.root_);
+      break;
+    }
+    case REL_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PlanRel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    PlanRel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PlanRel::GetClassData() const { return &_class_data_; }
+
+void PlanRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<PlanRel *>(to)->MergeFrom(
+      static_cast<const PlanRel &>(from));
+}
+
+
+void PlanRel::MergeFrom(const PlanRel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.PlanRel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.rel_type_case()) {
+    case kRel: {
+      _internal_mutable_rel()->::substrait::Rel::MergeFrom(from._internal_rel());
+      break;
+    }
+    case kRoot: {
+      _internal_mutable_root()->::substrait::RelRoot::MergeFrom(from._internal_root());
+      break;
+    }
+    case REL_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void PlanRel::CopyFrom(const PlanRel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.PlanRel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PlanRel::IsInitialized() const {
+  return true;
+}
+
+void PlanRel::InternalSwap(PlanRel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(rel_type_, other->rel_type_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata PlanRel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fplan_2eproto_getter, &descriptor_table_substrait_2fplan_2eproto_once,
+      file_level_metadata_substrait_2fplan_2eproto[0]);
+}
+
+// ===================================================================
+
+class Plan::_Internal {
+ public:
+  static const ::substrait::extensions::AdvancedExtension& advanced_extensions(const Plan* msg);
+};
+
+const ::substrait::extensions::AdvancedExtension&
+Plan::_Internal::advanced_extensions(const Plan* msg) {
+  return *msg->advanced_extensions_;
+}
+void Plan::clear_extension_uris() {
+  extension_uris_.Clear();
+}
+void Plan::clear_extensions() {
+  extensions_.Clear();
+}
+void Plan::clear_advanced_extensions() {
+  if (GetArenaForAllocation() == nullptr && advanced_extensions_ != nullptr) {
+    delete advanced_extensions_;
+  }
+  advanced_extensions_ = nullptr;
+}
+Plan::Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  extension_uris_(arena),
+  extensions_(arena),
+  relations_(arena),
+  expected_type_urls_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Plan)
+}
+Plan::Plan(const Plan& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      extension_uris_(from.extension_uris_),
+      extensions_(from.extensions_),
+      relations_(from.relations_),
+      expected_type_urls_(from.expected_type_urls_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_advanced_extensions()) {
+    advanced_extensions_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extensions_);
+  } else {
+    advanced_extensions_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Plan)
+}
+
+inline void Plan::SharedCtor() {
+advanced_extensions_ = nullptr;
+}
+
+Plan::~Plan() {
+  // @@protoc_insertion_point(destructor:substrait.Plan)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Plan::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete advanced_extensions_;
+}
+
+void Plan::ArenaDtor(void* object) {
+  Plan* _this = reinterpret_cast< Plan* >(object);
+  (void)_this;
+}
+void Plan::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Plan::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Plan::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Plan)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  extension_uris_.Clear();
+  extensions_.Clear();
+  relations_.Clear();
+  expected_type_urls_.Clear();
+  if (GetArenaForAllocation() == nullptr && advanced_extensions_ != nullptr) {
+    delete advanced_extensions_;
+  }
+  advanced_extensions_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_extension_uris(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_extensions(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.PlanRel relations = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_relations(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extensions = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extensions(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string expected_type_urls = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_expected_type_urls();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Plan.expected_type_urls"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Plan::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Plan)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_extension_uris_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_extension_uris(i), target, stream);
+  }
+
+  // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_extensions_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_extensions(i), target, stream);
+  }
+
+  // repeated .substrait.PlanRel relations = 3;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_relations_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, this->_internal_relations(i), target, stream);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extensions = 4;
+  if (this->_internal_has_advanced_extensions()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::advanced_extensions(this), target, stream);
+  }
+
+  // repeated string expected_type_urls = 5;
+  for (int i = 0, n = this->_internal_expected_type_urls_size(); i < n; i++) {
+    const auto& s = this->_internal_expected_type_urls(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.Plan.expected_type_urls");
+    target = stream->WriteString(5, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Plan)
+  return target;
+}
+
+size_t Plan::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Plan)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1;
+  total_size += 1UL * this->_internal_extension_uris_size();
+  for (const auto& msg : this->extension_uris_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2;
+  total_size += 1UL * this->_internal_extensions_size();
+  for (const auto& msg : this->extensions_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .substrait.PlanRel relations = 3;
+  total_size += 1UL * this->_internal_relations_size();
+  for (const auto& msg : this->relations_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated string expected_type_urls = 5;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(expected_type_urls_.size());
+  for (int i = 0, n = expected_type_urls_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      expected_type_urls_.Get(i));
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extensions = 4;
+  if (this->_internal_has_advanced_extensions()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extensions_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Plan::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Plan::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Plan::GetClassData() const { return &_class_data_; }
+
+void Plan::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Plan *>(to)->MergeFrom(
+      static_cast<const Plan &>(from));
+}
+
+
+void Plan::MergeFrom(const Plan& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Plan)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  extension_uris_.MergeFrom(from.extension_uris_);
+  extensions_.MergeFrom(from.extensions_);
+  relations_.MergeFrom(from.relations_);
+  expected_type_urls_.MergeFrom(from.expected_type_urls_);
+  if (from._internal_has_advanced_extensions()) {
+    _internal_mutable_advanced_extensions()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extensions());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Plan::CopyFrom(const Plan& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Plan)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Plan::IsInitialized() const {
+  return true;
+}
+
+void Plan::InternalSwap(Plan* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  extension_uris_.InternalSwap(&other->extension_uris_);
+  extensions_.InternalSwap(&other->extensions_);
+  relations_.InternalSwap(&other->relations_);
+  expected_type_urls_.InternalSwap(&other->expected_type_urls_);
+  swap(advanced_extensions_, other->advanced_extensions_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Plan::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2fplan_2eproto_getter, &descriptor_table_substrait_2fplan_2eproto_once,
+      file_level_metadata_substrait_2fplan_2eproto[1]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::substrait::PlanRel* Arena::CreateMaybeMessage< ::substrait::PlanRel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::PlanRel >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Plan* Arena::CreateMaybeMessage< ::substrait::Plan >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Plan >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/cpp/src/generated/substrait/plan.pb.h b/cpp/src/generated/substrait/plan.pb.h
new file mode 100644
index 000000000000..b31f812c569d
--- /dev/null
+++ b/cpp/src/generated/substrait/plan.pb.h
@@ -0,0 +1,951 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/plan.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fplan_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fplan_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3019000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3019003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "substrait/relations.pb.h"
+#include "substrait/extensions/extensions.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_substrait_2fplan_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_substrait_2fplan_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fplan_2eproto;
+namespace substrait {
+class Plan;
+struct PlanDefaultTypeInternal;
+extern PlanDefaultTypeInternal _Plan_default_instance_;
+class PlanRel;
+struct PlanRelDefaultTypeInternal;
+extern PlanRelDefaultTypeInternal _PlanRel_default_instance_;
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> ::substrait::Plan* Arena::CreateMaybeMessage<::substrait::Plan>(Arena*);
+template<> ::substrait::PlanRel* Arena::CreateMaybeMessage<::substrait::PlanRel>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace substrait {
+
+// ===================================================================
+
+class PlanRel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.PlanRel) */ {
+ public:
+  inline PlanRel() : PlanRel(nullptr) {}
+  ~PlanRel() override;
+  explicit constexpr PlanRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PlanRel(const PlanRel& from);
+  PlanRel(PlanRel&& from) noexcept
+    : PlanRel() {
+    *this = ::std::move(from);
+  }
+
+  inline PlanRel& operator=(const PlanRel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PlanRel& operator=(PlanRel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PlanRel& default_instance() {
+    return *internal_default_instance();
+  }
+  enum RelTypeCase {
+    kRel = 1,
+    kRoot = 2,
+    REL_TYPE_NOT_SET = 0,
+  };
+
+  static inline const PlanRel* internal_default_instance() {
+    return reinterpret_cast<const PlanRel*>(
+               &_PlanRel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(PlanRel& a, PlanRel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PlanRel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PlanRel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  PlanRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<PlanRel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PlanRel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PlanRel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PlanRel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.PlanRel";
+  }
+  protected:
+  explicit PlanRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRelFieldNumber = 1,
+    kRootFieldNumber = 2,
+  };
+  // .substrait.Rel rel = 1;
+  bool has_rel() const;
+  private:
+  bool _internal_has_rel() const;
+  public:
+  void clear_rel();
+  const ::substrait::Rel& rel() const;
+  PROTOBUF_NODISCARD ::substrait::Rel* release_rel();
+  ::substrait::Rel* mutable_rel();
+  void set_allocated_rel(::substrait::Rel* rel);
+  private:
+  const ::substrait::Rel& _internal_rel() const;
+  ::substrait::Rel* _internal_mutable_rel();
+  public:
+  void unsafe_arena_set_allocated_rel(
+      ::substrait::Rel* rel);
+  ::substrait::Rel* unsafe_arena_release_rel();
+
+  // .substrait.RelRoot root = 2;
+  bool has_root() const;
+  private:
+  bool _internal_has_root() const;
+  public:
+  void clear_root();
+  const ::substrait::RelRoot& root() const;
+  PROTOBUF_NODISCARD ::substrait::RelRoot* release_root();
+  ::substrait::RelRoot* mutable_root();
+  void set_allocated_root(::substrait::RelRoot* root);
+  private:
+  const ::substrait::RelRoot& _internal_root() const;
+  ::substrait::RelRoot* _internal_mutable_root();
+  public:
+  void unsafe_arena_set_allocated_root(
+      ::substrait::RelRoot* root);
+  ::substrait::RelRoot* unsafe_arena_release_root();
+
+  void clear_rel_type();
+  RelTypeCase rel_type_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.PlanRel)
+ private:
+  class _Internal;
+  void set_has_rel();
+  void set_has_root();
+
+  inline bool has_rel_type() const;
+  inline void clear_has_rel_type();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union RelTypeUnion {
+    constexpr RelTypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Rel* rel_;
+    ::substrait::RelRoot* root_;
+  } rel_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2fplan_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Plan final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Plan) */ {
+ public:
+  inline Plan() : Plan(nullptr) {}
+  ~Plan() override;
+  explicit constexpr Plan(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Plan(const Plan& from);
+  Plan(Plan&& from) noexcept
+    : Plan() {
+    *this = ::std::move(from);
+  }
+
+  inline Plan& operator=(const Plan& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Plan& operator=(Plan&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Plan& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Plan* internal_default_instance() {
+    return reinterpret_cast<const Plan*>(
+               &_Plan_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(Plan& a, Plan& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Plan* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Plan* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Plan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Plan>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Plan& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Plan& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Plan* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Plan";
+  }
+  protected:
+  explicit Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kExtensionUrisFieldNumber = 1,
+    kExtensionsFieldNumber = 2,
+    kRelationsFieldNumber = 3,
+    kExpectedTypeUrlsFieldNumber = 5,
+    kAdvancedExtensionsFieldNumber = 4,
+  };
+  // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1;
+  int extension_uris_size() const;
+  private:
+  int _internal_extension_uris_size() const;
+  public:
+  void clear_extension_uris();
+  ::substrait::extensions::SimpleExtensionURI* mutable_extension_uris(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >*
+      mutable_extension_uris();
+  private:
+  const ::substrait::extensions::SimpleExtensionURI& _internal_extension_uris(int index) const;
+  ::substrait::extensions::SimpleExtensionURI* _internal_add_extension_uris();
+  public:
+  const ::substrait::extensions::SimpleExtensionURI& extension_uris(int index) const;
+  ::substrait::extensions::SimpleExtensionURI* add_extension_uris();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >&
+      extension_uris() const;
+
+  // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2;
+  int extensions_size() const;
+  private:
+  int _internal_extensions_size() const;
+  public:
+  void clear_extensions();
+  ::substrait::extensions::SimpleExtensionDeclaration* mutable_extensions(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >*
+      mutable_extensions();
+  private:
+  const ::substrait::extensions::SimpleExtensionDeclaration& _internal_extensions(int index) const;
+  ::substrait::extensions::SimpleExtensionDeclaration* _internal_add_extensions();
+  public:
+  const ::substrait::extensions::SimpleExtensionDeclaration& extensions(int index) const;
+  ::substrait::extensions::SimpleExtensionDeclaration* add_extensions();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >&
+      extensions() const;
+
+  // repeated .substrait.PlanRel relations = 3;
+  int relations_size() const;
+  private:
+  int _internal_relations_size() const;
+  public:
+  void clear_relations();
+  ::substrait::PlanRel* mutable_relations(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >*
+      mutable_relations();
+  private:
+  const ::substrait::PlanRel& _internal_relations(int index) const;
+  ::substrait::PlanRel* _internal_add_relations();
+  public:
+  const ::substrait::PlanRel& relations(int index) const;
+  ::substrait::PlanRel* add_relations();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >&
+      relations() const;
+
+  // repeated string expected_type_urls = 5;
+  int expected_type_urls_size() const;
+  private:
+  int _internal_expected_type_urls_size() const;
+  public:
+  void clear_expected_type_urls();
+  const std::string& expected_type_urls(int index) const;
+  std::string* mutable_expected_type_urls(int index);
+  void set_expected_type_urls(int index, const std::string& value);
+  void set_expected_type_urls(int index, std::string&& value);
+  void set_expected_type_urls(int index, const char* value);
+  void set_expected_type_urls(int index, const char* value, size_t size);
+  std::string* add_expected_type_urls();
+  void add_expected_type_urls(const std::string& value);
+  void add_expected_type_urls(std::string&& value);
+  void add_expected_type_urls(const char* value);
+  void add_expected_type_urls(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& expected_type_urls() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_expected_type_urls();
+  private:
+  const std::string& _internal_expected_type_urls(int index) const;
+  std::string* _internal_add_expected_type_urls();
+  public:
+
+  // .substrait.extensions.AdvancedExtension advanced_extensions = 4;
+  bool has_advanced_extensions() const;
+  private:
+  bool _internal_has_advanced_extensions() const;
+  public:
+  void clear_advanced_extensions();
+  const ::substrait::extensions::AdvancedExtension& advanced_extensions() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extensions();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extensions();
+  void set_allocated_advanced_extensions(::substrait::extensions::AdvancedExtension* advanced_extensions);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extensions() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extensions();
+  public:
+  void unsafe_arena_set_allocated_advanced_extensions(
+      ::substrait::extensions::AdvancedExtension* advanced_extensions);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extensions();
+
+  // @@protoc_insertion_point(class_scope:substrait.Plan)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI > extension_uris_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration > extensions_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel > relations_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> expected_type_urls_;
+  ::substrait::extensions::AdvancedExtension* advanced_extensions_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2fplan_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// PlanRel
+
+// .substrait.Rel rel = 1;
+inline bool PlanRel::_internal_has_rel() const {
+  return rel_type_case() == kRel;
+}
+inline bool PlanRel::has_rel() const {
+  return _internal_has_rel();
+}
+inline void PlanRel::set_has_rel() {
+  _oneof_case_[0] = kRel;
+}
+inline ::substrait::Rel* PlanRel::release_rel() {
+  // @@protoc_insertion_point(field_release:substrait.PlanRel.rel)
+  if (_internal_has_rel()) {
+    clear_has_rel_type();
+      ::substrait::Rel* temp = rel_type_.rel_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.rel_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Rel& PlanRel::_internal_rel() const {
+  return _internal_has_rel()
+      ? *rel_type_.rel_
+      : reinterpret_cast< ::substrait::Rel&>(::substrait::_Rel_default_instance_);
+}
+inline const ::substrait::Rel& PlanRel::rel() const {
+  // @@protoc_insertion_point(field_get:substrait.PlanRel.rel)
+  return _internal_rel();
+}
+inline ::substrait::Rel* PlanRel::unsafe_arena_release_rel() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.PlanRel.rel)
+  if (_internal_has_rel()) {
+    clear_has_rel_type();
+    ::substrait::Rel* temp = rel_type_.rel_;
+    rel_type_.rel_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void PlanRel::unsafe_arena_set_allocated_rel(::substrait::Rel* rel) {
+  clear_rel_type();
+  if (rel) {
+    set_has_rel();
+    rel_type_.rel_ = rel;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.PlanRel.rel)
+}
+inline ::substrait::Rel* PlanRel::_internal_mutable_rel() {
+  if (!_internal_has_rel()) {
+    clear_rel_type();
+    set_has_rel();
+    rel_type_.rel_ = CreateMaybeMessage< ::substrait::Rel >(GetArenaForAllocation());
+  }
+  return rel_type_.rel_;
+}
+inline ::substrait::Rel* PlanRel::mutable_rel() {
+  ::substrait::Rel* _msg = _internal_mutable_rel();
+  // @@protoc_insertion_point(field_mutable:substrait.PlanRel.rel)
+  return _msg;
+}
+
+// .substrait.RelRoot root = 2;
+inline bool PlanRel::_internal_has_root() const {
+  return rel_type_case() == kRoot;
+}
+inline bool PlanRel::has_root() const {
+  return _internal_has_root();
+}
+inline void PlanRel::set_has_root() {
+  _oneof_case_[0] = kRoot;
+}
+inline ::substrait::RelRoot* PlanRel::release_root() {
+  // @@protoc_insertion_point(field_release:substrait.PlanRel.root)
+  if (_internal_has_root()) {
+    clear_has_rel_type();
+      ::substrait::RelRoot* temp = rel_type_.root_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.root_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::RelRoot& PlanRel::_internal_root() const {
+  return _internal_has_root()
+      ? *rel_type_.root_
+      : reinterpret_cast< ::substrait::RelRoot&>(::substrait::_RelRoot_default_instance_);
+}
+inline const ::substrait::RelRoot& PlanRel::root() const {
+  // @@protoc_insertion_point(field_get:substrait.PlanRel.root)
+  return _internal_root();
+}
+inline ::substrait::RelRoot* PlanRel::unsafe_arena_release_root() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.PlanRel.root)
+  if (_internal_has_root()) {
+    clear_has_rel_type();
+    ::substrait::RelRoot* temp = rel_type_.root_;
+    rel_type_.root_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void PlanRel::unsafe_arena_set_allocated_root(::substrait::RelRoot* root) {
+  clear_rel_type();
+  if (root) {
+    set_has_root();
+    rel_type_.root_ = root;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.PlanRel.root)
+}
+inline ::substrait::RelRoot* PlanRel::_internal_mutable_root() {
+  if (!_internal_has_root()) {
+    clear_rel_type();
+    set_has_root();
+    rel_type_.root_ = CreateMaybeMessage< ::substrait::RelRoot >(GetArenaForAllocation());
+  }
+  return rel_type_.root_;
+}
+inline ::substrait::RelRoot* PlanRel::mutable_root() {
+  ::substrait::RelRoot* _msg = _internal_mutable_root();
+  // @@protoc_insertion_point(field_mutable:substrait.PlanRel.root)
+  return _msg;
+}
+
+inline bool PlanRel::has_rel_type() const {
+  return rel_type_case() != REL_TYPE_NOT_SET;
+}
+inline void PlanRel::clear_has_rel_type() {
+  _oneof_case_[0] = REL_TYPE_NOT_SET;
+}
+inline PlanRel::RelTypeCase PlanRel::rel_type_case() const {
+  return PlanRel::RelTypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Plan
+
+// repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1;
+inline int Plan::_internal_extension_uris_size() const {
+  return extension_uris_.size();
+}
+inline int Plan::extension_uris_size() const {
+  return _internal_extension_uris_size();
+}
+inline ::substrait::extensions::SimpleExtensionURI* Plan::mutable_extension_uris(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Plan.extension_uris)
+  return extension_uris_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >*
+Plan::mutable_extension_uris() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Plan.extension_uris)
+  return &extension_uris_;
+}
+inline const ::substrait::extensions::SimpleExtensionURI& Plan::_internal_extension_uris(int index) const {
+  return extension_uris_.Get(index);
+}
+inline const ::substrait::extensions::SimpleExtensionURI& Plan::extension_uris(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Plan.extension_uris)
+  return _internal_extension_uris(index);
+}
+inline ::substrait::extensions::SimpleExtensionURI* Plan::_internal_add_extension_uris() {
+  return extension_uris_.Add();
+}
+inline ::substrait::extensions::SimpleExtensionURI* Plan::add_extension_uris() {
+  ::substrait::extensions::SimpleExtensionURI* _add = _internal_add_extension_uris();
+  // @@protoc_insertion_point(field_add:substrait.Plan.extension_uris)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >&
+Plan::extension_uris() const {
+  // @@protoc_insertion_point(field_list:substrait.Plan.extension_uris)
+  return extension_uris_;
+}
+
+// repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2;
+inline int Plan::_internal_extensions_size() const {
+  return extensions_.size();
+}
+inline int Plan::extensions_size() const {
+  return _internal_extensions_size();
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration* Plan::mutable_extensions(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Plan.extensions)
+  return extensions_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >*
+Plan::mutable_extensions() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Plan.extensions)
+  return &extensions_;
+}
+inline const ::substrait::extensions::SimpleExtensionDeclaration& Plan::_internal_extensions(int index) const {
+  return extensions_.Get(index);
+}
+inline const ::substrait::extensions::SimpleExtensionDeclaration& Plan::extensions(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Plan.extensions)
+  return _internal_extensions(index);
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration* Plan::_internal_add_extensions() {
+  return extensions_.Add();
+}
+inline ::substrait::extensions::SimpleExtensionDeclaration* Plan::add_extensions() {
+  ::substrait::extensions::SimpleExtensionDeclaration* _add = _internal_add_extensions();
+  // @@protoc_insertion_point(field_add:substrait.Plan.extensions)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >&
+Plan::extensions() const {
+  // @@protoc_insertion_point(field_list:substrait.Plan.extensions)
+  return extensions_;
+}
+
+// repeated .substrait.PlanRel relations = 3;
+inline int Plan::_internal_relations_size() const {
+  return relations_.size();
+}
+inline int Plan::relations_size() const {
+  return _internal_relations_size();
+}
+inline void Plan::clear_relations() {
+  relations_.Clear();
+}
+inline ::substrait::PlanRel* Plan::mutable_relations(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Plan.relations)
+  return relations_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >*
+Plan::mutable_relations() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Plan.relations)
+  return &relations_;
+}
+inline const ::substrait::PlanRel& Plan::_internal_relations(int index) const {
+  return relations_.Get(index);
+}
+inline const ::substrait::PlanRel& Plan::relations(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Plan.relations)
+  return _internal_relations(index);
+}
+inline ::substrait::PlanRel* Plan::_internal_add_relations() {
+  return relations_.Add();
+}
+inline ::substrait::PlanRel* Plan::add_relations() {
+  ::substrait::PlanRel* _add = _internal_add_relations();
+  // @@protoc_insertion_point(field_add:substrait.Plan.relations)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >&
+Plan::relations() const {
+  // @@protoc_insertion_point(field_list:substrait.Plan.relations)
+  return relations_;
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extensions = 4;
+inline bool Plan::_internal_has_advanced_extensions() const {
+  return this != internal_default_instance() && advanced_extensions_ != nullptr;
+}
+inline bool Plan::has_advanced_extensions() const {
+  return _internal_has_advanced_extensions();
+}
+inline const ::substrait::extensions::AdvancedExtension& Plan::_internal_advanced_extensions() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extensions_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& Plan::advanced_extensions() const {
+  // @@protoc_insertion_point(field_get:substrait.Plan.advanced_extensions)
+  return _internal_advanced_extensions();
+}
+inline void Plan::unsafe_arena_set_allocated_advanced_extensions(
+    ::substrait::extensions::AdvancedExtension* advanced_extensions) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions_);
+  }
+  advanced_extensions_ = advanced_extensions;
+  if (advanced_extensions) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Plan.advanced_extensions)
+}
+inline ::substrait::extensions::AdvancedExtension* Plan::release_advanced_extensions() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extensions_;
+  advanced_extensions_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* Plan::unsafe_arena_release_advanced_extensions() {
+  // @@protoc_insertion_point(field_release:substrait.Plan.advanced_extensions)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extensions_;
+  advanced_extensions_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* Plan::_internal_mutable_advanced_extensions() {
+  
+  if (advanced_extensions_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extensions_ = p;
+  }
+  return advanced_extensions_;
+}
+inline ::substrait::extensions::AdvancedExtension* Plan::mutable_advanced_extensions() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extensions();
+  // @@protoc_insertion_point(field_mutable:substrait.Plan.advanced_extensions)
+  return _msg;
+}
+inline void Plan::set_allocated_advanced_extensions(::substrait::extensions::AdvancedExtension* advanced_extensions) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions_);
+  }
+  if (advanced_extensions) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions));
+    if (message_arena != submessage_arena) {
+      advanced_extensions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extensions, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extensions_ = advanced_extensions;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Plan.advanced_extensions)
+}
+
+// repeated string expected_type_urls = 5;
+inline int Plan::_internal_expected_type_urls_size() const {
+  return expected_type_urls_.size();
+}
+inline int Plan::expected_type_urls_size() const {
+  return _internal_expected_type_urls_size();
+}
+inline void Plan::clear_expected_type_urls() {
+  expected_type_urls_.Clear();
+}
+inline std::string* Plan::add_expected_type_urls() {
+  std::string* _s = _internal_add_expected_type_urls();
+  // @@protoc_insertion_point(field_add_mutable:substrait.Plan.expected_type_urls)
+  return _s;
+}
+inline const std::string& Plan::_internal_expected_type_urls(int index) const {
+  return expected_type_urls_.Get(index);
+}
+inline const std::string& Plan::expected_type_urls(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Plan.expected_type_urls)
+  return _internal_expected_type_urls(index);
+}
+inline std::string* Plan::mutable_expected_type_urls(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Plan.expected_type_urls)
+  return expected_type_urls_.Mutable(index);
+}
+inline void Plan::set_expected_type_urls(int index, const std::string& value) {
+  expected_type_urls_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.Plan.expected_type_urls)
+}
+inline void Plan::set_expected_type_urls(int index, std::string&& value) {
+  expected_type_urls_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.Plan.expected_type_urls)
+}
+inline void Plan::set_expected_type_urls(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  expected_type_urls_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.Plan.expected_type_urls)
+}
+inline void Plan::set_expected_type_urls(int index, const char* value, size_t size) {
+  expected_type_urls_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.Plan.expected_type_urls)
+}
+inline std::string* Plan::_internal_add_expected_type_urls() {
+  return expected_type_urls_.Add();
+}
+inline void Plan::add_expected_type_urls(const std::string& value) {
+  expected_type_urls_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.Plan.expected_type_urls)
+}
+inline void Plan::add_expected_type_urls(std::string&& value) {
+  expected_type_urls_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.Plan.expected_type_urls)
+}
+inline void Plan::add_expected_type_urls(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  expected_type_urls_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.Plan.expected_type_urls)
+}
+inline void Plan::add_expected_type_urls(const char* value, size_t size) {
+  expected_type_urls_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.Plan.expected_type_urls)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+Plan::expected_type_urls() const {
+  // @@protoc_insertion_point(field_list:substrait.Plan.expected_type_urls)
+  return expected_type_urls_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+Plan::mutable_expected_type_urls() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Plan.expected_type_urls)
+  return &expected_type_urls_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace substrait
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fplan_2eproto
diff --git a/cpp/src/generated/substrait/relations.pb.cc b/cpp/src/generated/substrait/relations.pb.cc
new file mode 100644
index 000000000000..f4d4e9044489
--- /dev/null
+++ b/cpp/src/generated/substrait/relations.pb.cc
@@ -0,0 +1,9153 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/relations.proto
+
+#include "substrait/relations.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace substrait {
+constexpr RelCommon_Direct::RelCommon_Direct(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
+struct RelCommon_DirectDefaultTypeInternal {
+  constexpr RelCommon_DirectDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~RelCommon_DirectDefaultTypeInternal() {}
+  union {
+    RelCommon_Direct _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_DirectDefaultTypeInternal _RelCommon_Direct_default_instance_;
+constexpr RelCommon_Emit::RelCommon_Emit(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : output_mapping_()
+  , _output_mapping_cached_byte_size_(0){}
+struct RelCommon_EmitDefaultTypeInternal {
+  constexpr RelCommon_EmitDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~RelCommon_EmitDefaultTypeInternal() {}
+  union {
+    RelCommon_Emit _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_EmitDefaultTypeInternal _RelCommon_Emit_default_instance_;
+constexpr RelCommon_Hint_Stats::RelCommon_Hint_Stats(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : advanced_extension_(nullptr)
+  , row_count_(0)
+  , record_size_(0){}
+struct RelCommon_Hint_StatsDefaultTypeInternal {
+  constexpr RelCommon_Hint_StatsDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~RelCommon_Hint_StatsDefaultTypeInternal() {}
+  union {
+    RelCommon_Hint_Stats _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_Hint_StatsDefaultTypeInternal _RelCommon_Hint_Stats_default_instance_;
+constexpr RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : advanced_extension_(nullptr){}
+struct RelCommon_Hint_RuntimeConstraintDefaultTypeInternal {
+  constexpr RelCommon_Hint_RuntimeConstraintDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~RelCommon_Hint_RuntimeConstraintDefaultTypeInternal() {}
+  union {
+    RelCommon_Hint_RuntimeConstraint _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_Hint_RuntimeConstraintDefaultTypeInternal _RelCommon_Hint_RuntimeConstraint_default_instance_;
+constexpr RelCommon_Hint::RelCommon_Hint(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : stats_(nullptr)
+  , constraint_(nullptr)
+  , advanced_extension_(nullptr){}
+struct RelCommon_HintDefaultTypeInternal {
+  constexpr RelCommon_HintDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~RelCommon_HintDefaultTypeInternal() {}
+  union {
+    RelCommon_Hint _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_HintDefaultTypeInternal _RelCommon_Hint_default_instance_;
+constexpr RelCommon::RelCommon(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : hint_(nullptr)
+  , advanced_extension_(nullptr)
+  , _oneof_case_{}{}
+struct RelCommonDefaultTypeInternal {
+  constexpr RelCommonDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~RelCommonDefaultTypeInternal() {}
+  union {
+    RelCommon _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommonDefaultTypeInternal _RelCommon_default_instance_;
+constexpr ReadRel_NamedTable::ReadRel_NamedTable(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : names_()
+  , advanced_extension_(nullptr){}
+struct ReadRel_NamedTableDefaultTypeInternal {
+  constexpr ReadRel_NamedTableDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ReadRel_NamedTableDefaultTypeInternal() {}
+  union {
+    ReadRel_NamedTable _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_NamedTableDefaultTypeInternal _ReadRel_NamedTable_default_instance_;
+constexpr ReadRel_VirtualTable::ReadRel_VirtualTable(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : values_(){}
+struct ReadRel_VirtualTableDefaultTypeInternal {
+  constexpr ReadRel_VirtualTableDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ReadRel_VirtualTableDefaultTypeInternal() {}
+  union {
+    ReadRel_VirtualTable _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_VirtualTableDefaultTypeInternal _ReadRel_VirtualTable_default_instance_;
+constexpr ReadRel_ExtensionTable::ReadRel_ExtensionTable(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : detail_(nullptr){}
+struct ReadRel_ExtensionTableDefaultTypeInternal {
+  constexpr ReadRel_ExtensionTableDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ReadRel_ExtensionTableDefaultTypeInternal() {}
+  union {
+    ReadRel_ExtensionTable _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_ExtensionTableDefaultTypeInternal _ReadRel_ExtensionTable_default_instance_;
+constexpr ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : format_(0)
+
+  , partition_index_(uint64_t{0u})
+  , start_(uint64_t{0u})
+  , length_(uint64_t{0u})
+  , _oneof_case_{}{}
+struct ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal {
+  constexpr ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal() {}
+  union {
+    ReadRel_LocalFiles_FileOrFiles _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal _ReadRel_LocalFiles_FileOrFiles_default_instance_;
+constexpr ReadRel_LocalFiles::ReadRel_LocalFiles(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : items_()
+  , advanced_extension_(nullptr){}
+struct ReadRel_LocalFilesDefaultTypeInternal {
+  constexpr ReadRel_LocalFilesDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ReadRel_LocalFilesDefaultTypeInternal() {}
+  union {
+    ReadRel_LocalFiles _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_LocalFilesDefaultTypeInternal _ReadRel_LocalFiles_default_instance_;
+constexpr ReadRel::ReadRel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : common_(nullptr)
+  , base_schema_(nullptr)
+  , filter_(nullptr)
+  , projection_(nullptr)
+  , advanced_extension_(nullptr)
+  , _oneof_case_{}{}
+struct ReadRelDefaultTypeInternal {
+  constexpr ReadRelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ReadRelDefaultTypeInternal() {}
+  union {
+    ReadRel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRelDefaultTypeInternal _ReadRel_default_instance_;
+constexpr ProjectRel::ProjectRel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : expressions_()
+  , common_(nullptr)
+  , input_(nullptr)
+  , advanced_extension_(nullptr){}
+struct ProjectRelDefaultTypeInternal {
+  constexpr ProjectRelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ProjectRelDefaultTypeInternal() {}
+  union {
+    ProjectRel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ProjectRelDefaultTypeInternal _ProjectRel_default_instance_;
+constexpr JoinRel::JoinRel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : common_(nullptr)
+  , left_(nullptr)
+  , right_(nullptr)
+  , expression_(nullptr)
+  , post_join_filter_(nullptr)
+  , advanced_extension_(nullptr)
+  , type_(0)
+{}
+struct JoinRelDefaultTypeInternal {
+  constexpr JoinRelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~JoinRelDefaultTypeInternal() {}
+  union {
+    JoinRel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT JoinRelDefaultTypeInternal _JoinRel_default_instance_;
+constexpr FetchRel::FetchRel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : common_(nullptr)
+  , input_(nullptr)
+  , advanced_extension_(nullptr)
+  , offset_(int64_t{0})
+  , count_(int64_t{0}){}
+struct FetchRelDefaultTypeInternal {
+  constexpr FetchRelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FetchRelDefaultTypeInternal() {}
+  union {
+    FetchRel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FetchRelDefaultTypeInternal _FetchRel_default_instance_;
+constexpr AggregateRel_Grouping::AggregateRel_Grouping(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : grouping_expressions_(){}
+struct AggregateRel_GroupingDefaultTypeInternal {
+  constexpr AggregateRel_GroupingDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~AggregateRel_GroupingDefaultTypeInternal() {}
+  union {
+    AggregateRel_Grouping _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRel_GroupingDefaultTypeInternal _AggregateRel_Grouping_default_instance_;
+constexpr AggregateRel_Measure::AggregateRel_Measure(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : measure_(nullptr)
+  , filter_(nullptr){}
+struct AggregateRel_MeasureDefaultTypeInternal {
+  constexpr AggregateRel_MeasureDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~AggregateRel_MeasureDefaultTypeInternal() {}
+  union {
+    AggregateRel_Measure _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRel_MeasureDefaultTypeInternal _AggregateRel_Measure_default_instance_;
+constexpr AggregateRel::AggregateRel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : groupings_()
+  , measures_()
+  , common_(nullptr)
+  , input_(nullptr)
+  , advanced_extension_(nullptr){}
+struct AggregateRelDefaultTypeInternal {
+  constexpr AggregateRelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~AggregateRelDefaultTypeInternal() {}
+  union {
+    AggregateRel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRelDefaultTypeInternal _AggregateRel_default_instance_;
+constexpr SortRel::SortRel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : sorts_()
+  , common_(nullptr)
+  , input_(nullptr)
+  , advanced_extension_(nullptr){}
+struct SortRelDefaultTypeInternal {
+  constexpr SortRelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~SortRelDefaultTypeInternal() {}
+  union {
+    SortRel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SortRelDefaultTypeInternal _SortRel_default_instance_;
+constexpr FilterRel::FilterRel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : common_(nullptr)
+  , input_(nullptr)
+  , condition_(nullptr)
+  , advanced_extension_(nullptr){}
+struct FilterRelDefaultTypeInternal {
+  constexpr FilterRelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~FilterRelDefaultTypeInternal() {}
+  union {
+    FilterRel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FilterRelDefaultTypeInternal _FilterRel_default_instance_;
+constexpr SetRel::SetRel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : inputs_()
+  , common_(nullptr)
+  , advanced_extension_(nullptr)
+  , op_(0)
+{}
+struct SetRelDefaultTypeInternal {
+  constexpr SetRelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~SetRelDefaultTypeInternal() {}
+  union {
+    SetRel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SetRelDefaultTypeInternal _SetRel_default_instance_;
+constexpr ExtensionSingleRel::ExtensionSingleRel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : common_(nullptr)
+  , input_(nullptr)
+  , detail_(nullptr){}
+struct ExtensionSingleRelDefaultTypeInternal {
+  constexpr ExtensionSingleRelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ExtensionSingleRelDefaultTypeInternal() {}
+  union {
+    ExtensionSingleRel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionSingleRelDefaultTypeInternal _ExtensionSingleRel_default_instance_;
+constexpr ExtensionLeafRel::ExtensionLeafRel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : common_(nullptr)
+  , detail_(nullptr){}
+struct ExtensionLeafRelDefaultTypeInternal {
+  constexpr ExtensionLeafRelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ExtensionLeafRelDefaultTypeInternal() {}
+  union {
+    ExtensionLeafRel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionLeafRelDefaultTypeInternal _ExtensionLeafRel_default_instance_;
+constexpr ExtensionMultiRel::ExtensionMultiRel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : inputs_()
+  , common_(nullptr)
+  , detail_(nullptr){}
+struct ExtensionMultiRelDefaultTypeInternal {
+  constexpr ExtensionMultiRelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~ExtensionMultiRelDefaultTypeInternal() {}
+  union {
+    ExtensionMultiRel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionMultiRelDefaultTypeInternal _ExtensionMultiRel_default_instance_;
+constexpr RelRoot::RelRoot(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : names_()
+  , input_(nullptr){}
+struct RelRootDefaultTypeInternal {
+  constexpr RelRootDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~RelRootDefaultTypeInternal() {}
+  union {
+    RelRoot _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelRootDefaultTypeInternal _RelRoot_default_instance_;
+constexpr Rel::Rel(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct RelDefaultTypeInternal {
+  constexpr RelDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~RelDefaultTypeInternal() {}
+  union {
+    Rel _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelDefaultTypeInternal _Rel_default_instance_;
+}  // namespace substrait
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2frelations_2eproto[26];
+static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2frelations_2eproto[3];
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2frelations_2eproto = nullptr;
+
+const uint32_t TableStruct_substrait_2frelations_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Direct, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Emit, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Emit, output_mapping_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, row_count_),
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, record_size_),
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, advanced_extension_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_RuntimeConstraint, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_RuntimeConstraint, advanced_extension_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, stats_),
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, constraint_),
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, advanced_extension_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, hint_),
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, advanced_extension_),
+  PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, emit_kind_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, names_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, advanced_extension_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_VirtualTable, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_VirtualTable, values_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_ExtensionTable, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_ExtensionTable, detail_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, format_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, partition_index_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, start_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, length_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, path_type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, items_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, advanced_extension_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, common_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, base_schema_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, filter_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, projection_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, advanced_extension_),
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, read_type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, common_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, input_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, expressions_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, advanced_extension_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, common_),
+  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, left_),
+  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, right_),
+  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, expression_),
+  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, post_join_filter_),
+  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, advanced_extension_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, common_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, input_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, offset_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, count_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, advanced_extension_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Grouping, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Grouping, grouping_expressions_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, measure_),
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, filter_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, common_),
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, input_),
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, groupings_),
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, measures_),
+  PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, advanced_extension_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::SortRel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::SortRel, common_),
+  PROTOBUF_FIELD_OFFSET(::substrait::SortRel, input_),
+  PROTOBUF_FIELD_OFFSET(::substrait::SortRel, sorts_),
+  PROTOBUF_FIELD_OFFSET(::substrait::SortRel, advanced_extension_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, common_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, input_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, condition_),
+  PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, advanced_extension_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::SetRel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::SetRel, common_),
+  PROTOBUF_FIELD_OFFSET(::substrait::SetRel, inputs_),
+  PROTOBUF_FIELD_OFFSET(::substrait::SetRel, op_),
+  PROTOBUF_FIELD_OFFSET(::substrait::SetRel, advanced_extension_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, common_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, input_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, detail_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, common_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, detail_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, common_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, inputs_),
+  PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, detail_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, input_),
+  PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, names_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Rel, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::Rel, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::Rel, rel_type_),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, -1, sizeof(::substrait::RelCommon_Direct)},
+  { 6, -1, -1, sizeof(::substrait::RelCommon_Emit)},
+  { 13, -1, -1, sizeof(::substrait::RelCommon_Hint_Stats)},
+  { 22, -1, -1, sizeof(::substrait::RelCommon_Hint_RuntimeConstraint)},
+  { 29, -1, -1, sizeof(::substrait::RelCommon_Hint)},
+  { 38, -1, -1, sizeof(::substrait::RelCommon)},
+  { 49, -1, -1, sizeof(::substrait::ReadRel_NamedTable)},
+  { 57, -1, -1, sizeof(::substrait::ReadRel_VirtualTable)},
+  { 64, -1, -1, sizeof(::substrait::ReadRel_ExtensionTable)},
+  { 71, -1, -1, sizeof(::substrait::ReadRel_LocalFiles_FileOrFiles)},
+  { 86, -1, -1, sizeof(::substrait::ReadRel_LocalFiles)},
+  { 94, -1, -1, sizeof(::substrait::ReadRel)},
+  { 110, -1, -1, sizeof(::substrait::ProjectRel)},
+  { 120, -1, -1, sizeof(::substrait::JoinRel)},
+  { 133, -1, -1, sizeof(::substrait::FetchRel)},
+  { 144, -1, -1, sizeof(::substrait::AggregateRel_Grouping)},
+  { 151, -1, -1, sizeof(::substrait::AggregateRel_Measure)},
+  { 159, -1, -1, sizeof(::substrait::AggregateRel)},
+  { 170, -1, -1, sizeof(::substrait::SortRel)},
+  { 180, -1, -1, sizeof(::substrait::FilterRel)},
+  { 190, -1, -1, sizeof(::substrait::SetRel)},
+  { 200, -1, -1, sizeof(::substrait::ExtensionSingleRel)},
+  { 209, -1, -1, sizeof(::substrait::ExtensionLeafRel)},
+  { 217, -1, -1, sizeof(::substrait::ExtensionMultiRel)},
+  { 226, -1, -1, sizeof(::substrait::RelRoot)},
+  { 234, -1, -1, sizeof(::substrait::Rel)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelCommon_Direct_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelCommon_Emit_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelCommon_Hint_Stats_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelCommon_Hint_RuntimeConstraint_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelCommon_Hint_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelCommon_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ReadRel_NamedTable_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ReadRel_VirtualTable_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ReadRel_ExtensionTable_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ReadRel_LocalFiles_FileOrFiles_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ReadRel_LocalFiles_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ReadRel_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ProjectRel_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_JoinRel_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FetchRel_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_AggregateRel_Grouping_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_AggregateRel_Measure_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_AggregateRel_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_SortRel_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_FilterRel_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_SetRel_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ExtensionSingleRel_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ExtensionLeafRel_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_ExtensionMultiRel_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_RelRoot_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Rel_default_instance_),
+};
+
+const char descriptor_table_protodef_substrait_2frelations_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\031substrait/relations.proto\022\tsubstrait\032\024"
+  "substrait/type.proto\032\032substrait/expressi"
+  "on.proto\032%substrait/extensions/extension"
+  "s.proto\032\031google/protobuf/any.proto\"\231\005\n\tR"
+  "elCommon\022-\n\006direct\030\001 \001(\0132\033.substrait.Rel"
+  "Common.DirectH\000\022)\n\004emit\030\002 \001(\0132\031.substrai"
+  "t.RelCommon.EmitH\000\022\'\n\004hint\030\003 \001(\0132\031.subst"
+  "rait.RelCommon.Hint\022C\n\022advanced_extensio"
+  "n\030\004 \001(\0132\'.substrait.extensions.AdvancedE"
+  "xtension\032\010\n\006Direct\032\036\n\004Emit\022\026\n\016output_map"
+  "ping\030\001 \003(\005\032\214\003\n\004Hint\022.\n\005stats\030\001 \001(\0132\037.sub"
+  "strait.RelCommon.Hint.Stats\022\?\n\nconstrain"
+  "t\030\002 \001(\0132+.substrait.RelCommon.Hint.Runti"
+  "meConstraint\022C\n\022advanced_extension\030\n \001(\013"
+  "2\'.substrait.extensions.AdvancedExtensio"
+  "n\032t\n\005Stats\022\021\n\trow_count\030\001 \001(\001\022\023\n\013record_"
+  "size\030\002 \001(\001\022C\n\022advanced_extension\030\n \001(\0132\'"
+  ".substrait.extensions.AdvancedExtension\032"
+  "X\n\021RuntimeConstraint\022C\n\022advanced_extensi"
+  "on\030\n \001(\0132\'.substrait.extensions.Advanced"
+  "ExtensionB\013\n\temit_kind\"\227\t\n\007ReadRel\022$\n\006co"
+  "mmon\030\001 \001(\0132\024.substrait.RelCommon\022+\n\013base"
+  "_schema\030\002 \001(\0132\026.substrait.NamedStruct\022%\n"
+  "\006filter\030\003 \001(\0132\025.substrait.Expression\0228\n\n"
+  "projection\030\004 \001(\0132$.substrait.Expression."
+  "MaskExpression\022C\n\022advanced_extension\030\n \001"
+  "(\0132\'.substrait.extensions.AdvancedExtens"
+  "ion\0228\n\rvirtual_table\030\005 \001(\0132\037.substrait.R"
+  "eadRel.VirtualTableH\000\0224\n\013local_files\030\006 \001"
+  "(\0132\035.substrait.ReadRel.LocalFilesH\000\0224\n\013n"
+  "amed_table\030\007 \001(\0132\035.substrait.ReadRel.Nam"
+  "edTableH\000\022<\n\017extension_table\030\010 \001(\0132!.sub"
+  "strait.ReadRel.ExtensionTableH\000\032`\n\nNamed"
+  "Table\022\r\n\005names\030\001 \003(\t\022C\n\022advanced_extensi"
+  "on\030\n \001(\0132\'.substrait.extensions.Advanced"
+  "Extension\032D\n\014VirtualTable\0224\n\006values\030\001 \003("
+  "\0132$.substrait.Expression.Literal.Struct\032"
+  "6\n\016ExtensionTable\022$\n\006detail\030\001 \001(\0132\024.goog"
+  "le.protobuf.Any\032\301\003\n\nLocalFiles\0228\n\005items\030"
+  "\001 \003(\0132).substrait.ReadRel.LocalFiles.Fil"
+  "eOrFiles\022C\n\022advanced_extension\030\n \001(\0132\'.s"
+  "ubstrait.extensions.AdvancedExtension\032\263\002"
+  "\n\013FileOrFiles\022\022\n\010uri_path\030\001 \001(\tH\000\022\027\n\ruri"
+  "_path_glob\030\002 \001(\tH\000\022\022\n\010uri_file\030\003 \001(\tH\000\022\024"
+  "\n\nuri_folder\030\004 \001(\tH\000\022D\n\006format\030\005 \001(\01624.s"
+  "ubstrait.ReadRel.LocalFiles.FileOrFiles."
+  "FileFormat\022\027\n\017partition_index\030\006 \001(\004\022\r\n\005s"
+  "tart\030\007 \001(\004\022\016\n\006length\030\010 \001(\004\"B\n\nFileFormat"
+  "\022\033\n\027FILE_FORMAT_UNSPECIFIED\020\000\022\027\n\023FILE_FO"
+  "RMAT_PARQUET\020\001B\013\n\tpath_typeB\013\n\tread_type"
+  "\"\302\001\n\nProjectRel\022$\n\006common\030\001 \001(\0132\024.substr"
+  "ait.RelCommon\022\035\n\005input\030\002 \001(\0132\016.substrait"
+  ".Rel\022*\n\013expressions\030\003 \003(\0132\025.substrait.Ex"
+  "pression\022C\n\022advanced_extension\030\n \001(\0132\'.s"
+  "ubstrait.extensions.AdvancedExtension\"\333\003"
+  "\n\007JoinRel\022$\n\006common\030\001 \001(\0132\024.substrait.Re"
+  "lCommon\022\034\n\004left\030\002 \001(\0132\016.substrait.Rel\022\035\n"
+  "\005right\030\003 \001(\0132\016.substrait.Rel\022)\n\nexpressi"
+  "on\030\004 \001(\0132\025.substrait.Expression\022/\n\020post_"
+  "join_filter\030\005 \001(\0132\025.substrait.Expression"
+  "\022)\n\004type\030\006 \001(\0162\033.substrait.JoinRel.JoinT"
+  "ype\022C\n\022advanced_extension\030\n \001(\0132\'.substr"
+  "ait.extensions.AdvancedExtension\"\240\001\n\010Joi"
+  "nType\022\031\n\025JOIN_TYPE_UNSPECIFIED\020\000\022\023\n\017JOIN"
+  "_TYPE_INNER\020\001\022\023\n\017JOIN_TYPE_OUTER\020\002\022\022\n\016JO"
+  "IN_TYPE_LEFT\020\003\022\023\n\017JOIN_TYPE_RIGHT\020\004\022\022\n\016J"
+  "OIN_TYPE_SEMI\020\005\022\022\n\016JOIN_TYPE_ANTI\020\006\"\263\001\n\010"
+  "FetchRel\022$\n\006common\030\001 \001(\0132\024.substrait.Rel"
+  "Common\022\035\n\005input\030\002 \001(\0132\016.substrait.Rel\022\016\n"
+  "\006offset\030\003 \001(\003\022\r\n\005count\030\004 \001(\003\022C\n\022advanced"
+  "_extension\030\n \001(\0132\'.substrait.extensions."
+  "AdvancedExtension\"\242\003\n\014AggregateRel\022$\n\006co"
+  "mmon\030\001 \001(\0132\024.substrait.RelCommon\022\035\n\005inpu"
+  "t\030\002 \001(\0132\016.substrait.Rel\0223\n\tgroupings\030\003 \003"
+  "(\0132 .substrait.AggregateRel.Grouping\0221\n\010"
+  "measures\030\004 \003(\0132\037.substrait.AggregateRel."
+  "Measure\022C\n\022advanced_extension\030\n \001(\0132\'.su"
+  "bstrait.extensions.AdvancedExtension\032\?\n\010"
+  "Grouping\0223\n\024grouping_expressions\030\001 \003(\0132\025"
+  ".substrait.Expression\032_\n\007Measure\022-\n\007meas"
+  "ure\030\001 \001(\0132\034.substrait.AggregateFunction\022"
+  "%\n\006filter\030\002 \001(\0132\025.substrait.Expression\"\270"
+  "\001\n\007SortRel\022$\n\006common\030\001 \001(\0132\024.substrait.R"
+  "elCommon\022\035\n\005input\030\002 \001(\0132\016.substrait.Rel\022"
+  "#\n\005sorts\030\003 \003(\0132\024.substrait.SortField\022C\n\022"
+  "advanced_extension\030\n \001(\0132\'.substrait.ext"
+  "ensions.AdvancedExtension\"\277\001\n\tFilterRel\022"
+  "$\n\006common\030\001 \001(\0132\024.substrait.RelCommon\022\035\n"
+  "\005input\030\002 \001(\0132\016.substrait.Rel\022(\n\tconditio"
+  "n\030\003 \001(\0132\025.substrait.Expression\022C\n\022advanc"
+  "ed_extension\030\n \001(\0132\'.substrait.extension"
+  "s.AdvancedExtension\"\203\003\n\006SetRel\022$\n\006common"
+  "\030\001 \001(\0132\024.substrait.RelCommon\022\036\n\006inputs\030\002"
+  " \003(\0132\016.substrait.Rel\022#\n\002op\030\003 \001(\0162\027.subst"
+  "rait.SetRel.SetOp\022C\n\022advanced_extension\030"
+  "\n \001(\0132\'.substrait.extensions.AdvancedExt"
+  "ension\"\310\001\n\005SetOp\022\026\n\022SET_OP_UNSPECIFIED\020\000"
+  "\022\030\n\024SET_OP_MINUS_PRIMARY\020\001\022\031\n\025SET_OP_MIN"
+  "US_MULTISET\020\002\022\037\n\033SET_OP_INTERSECTION_PRI"
+  "MARY\020\003\022 \n\034SET_OP_INTERSECTION_MULTISET\020\004"
+  "\022\031\n\025SET_OP_UNION_DISTINCT\020\005\022\024\n\020SET_OP_UN"
+  "ION_ALL\020\006\"\177\n\022ExtensionSingleRel\022$\n\006commo"
+  "n\030\001 \001(\0132\024.substrait.RelCommon\022\035\n\005input\030\002"
+  " \001(\0132\016.substrait.Rel\022$\n\006detail\030\003 \001(\0132\024.g"
+  "oogle.protobuf.Any\"^\n\020ExtensionLeafRel\022$"
+  "\n\006common\030\001 \001(\0132\024.substrait.RelCommon\022$\n\006"
+  "detail\030\002 \001(\0132\024.google.protobuf.Any\"\177\n\021Ex"
+  "tensionMultiRel\022$\n\006common\030\001 \001(\0132\024.substr"
+  "ait.RelCommon\022\036\n\006inputs\030\002 \003(\0132\016.substrai"
+  "t.Rel\022$\n\006detail\030\003 \001(\0132\024.google.protobuf."
+  "Any\"7\n\007RelRoot\022\035\n\005input\030\001 \001(\0132\016.substrai"
+  "t.Rel\022\r\n\005names\030\002 \003(\t\"\360\003\n\003Rel\022\"\n\004read\030\001 \001"
+  "(\0132\022.substrait.ReadRelH\000\022&\n\006filter\030\002 \001(\013"
+  "2\024.substrait.FilterRelH\000\022$\n\005fetch\030\003 \001(\0132"
+  "\023.substrait.FetchRelH\000\022,\n\taggregate\030\004 \001("
+  "\0132\027.substrait.AggregateRelH\000\022\"\n\004sort\030\005 \001"
+  "(\0132\022.substrait.SortRelH\000\022\"\n\004join\030\006 \001(\0132\022"
+  ".substrait.JoinRelH\000\022(\n\007project\030\007 \001(\0132\025."
+  "substrait.ProjectRelH\000\022 \n\003set\030\010 \001(\0132\021.su"
+  "bstrait.SetRelH\000\0229\n\020extension_single\030\t \001"
+  "(\0132\035.substrait.ExtensionSingleRelH\000\0227\n\017e"
+  "xtension_multi\030\n \001(\0132\034.substrait.Extensi"
+  "onMultiRelH\000\0225\n\016extension_leaf\030\013 \001(\0132\033.s"
+  "ubstrait.ExtensionLeafRelH\000B\n\n\010rel_typeB"
+  "+\n\022io.substrait.protoP\001\252\002\022Substrait.Prot"
+  "obufb\006proto3"
+  ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2frelations_2eproto_deps[4] = {
+  &::descriptor_table_google_2fprotobuf_2fany_2eproto,
+  &::descriptor_table_substrait_2fexpression_2eproto,
+  &::descriptor_table_substrait_2fextensions_2fextensions_2eproto,
+  &::descriptor_table_substrait_2ftype_2eproto,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2frelations_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2frelations_2eproto = {
+  false, false, 5012, descriptor_table_protodef_substrait_2frelations_2eproto, "substrait/relations.proto", 
+  &descriptor_table_substrait_2frelations_2eproto_once, descriptor_table_substrait_2frelations_2eproto_deps, 4, 26,
+  schemas, file_default_instances, TableStruct_substrait_2frelations_2eproto::offsets,
+  file_level_metadata_substrait_2frelations_2eproto, file_level_enum_descriptors_substrait_2frelations_2eproto, file_level_service_descriptors_substrait_2frelations_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2frelations_2eproto_getter() {
+  return &descriptor_table_substrait_2frelations_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2frelations_2eproto(&descriptor_table_substrait_2frelations_2eproto);
+namespace substrait {
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2frelations_2eproto);
+  return file_level_enum_descriptors_substrait_2frelations_2eproto[0];
+}
+bool ReadRel_LocalFiles_FileOrFiles_FileFormat_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FILE_FORMAT_UNSPECIFIED;
+constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FILE_FORMAT_PARQUET;
+constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FileFormat_MIN;
+constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FileFormat_MAX;
+constexpr int ReadRel_LocalFiles_FileOrFiles::FileFormat_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinRel_JoinType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2frelations_2eproto);
+  return file_level_enum_descriptors_substrait_2frelations_2eproto[1];
+}
+bool JoinRel_JoinType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_UNSPECIFIED;
+constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_INNER;
+constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_OUTER;
+constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_LEFT;
+constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_RIGHT;
+constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_SEMI;
+constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_ANTI;
+constexpr JoinRel_JoinType JoinRel::JoinType_MIN;
+constexpr JoinRel_JoinType JoinRel::JoinType_MAX;
+constexpr int JoinRel::JoinType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetRel_SetOp_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2frelations_2eproto);
+  return file_level_enum_descriptors_substrait_2frelations_2eproto[2];
+}
+bool SetRel_SetOp_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr SetRel_SetOp SetRel::SET_OP_UNSPECIFIED;
+constexpr SetRel_SetOp SetRel::SET_OP_MINUS_PRIMARY;
+constexpr SetRel_SetOp SetRel::SET_OP_MINUS_MULTISET;
+constexpr SetRel_SetOp SetRel::SET_OP_INTERSECTION_PRIMARY;
+constexpr SetRel_SetOp SetRel::SET_OP_INTERSECTION_MULTISET;
+constexpr SetRel_SetOp SetRel::SET_OP_UNION_DISTINCT;
+constexpr SetRel_SetOp SetRel::SET_OP_UNION_ALL;
+constexpr SetRel_SetOp SetRel::SetOp_MIN;
+constexpr SetRel_SetOp SetRel::SetOp_MAX;
+constexpr int SetRel::SetOp_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+
+// ===================================================================
+
+class RelCommon_Direct::_Internal {
+ public:
+};
+
+RelCommon_Direct::RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
+  // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Direct)
+}
+RelCommon_Direct::RelCommon_Direct(const RelCommon_Direct& from)
+  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Direct)
+}
+
+
+
+
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Direct::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Direct::GetClassData() const { return &_class_data_; }
+
+
+
+
+
+
+
+::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Direct::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[0]);
+}
+
+// ===================================================================
+
+class RelCommon_Emit::_Internal {
+ public:
+};
+
+RelCommon_Emit::RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  output_mapping_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Emit)
+}
+RelCommon_Emit::RelCommon_Emit(const RelCommon_Emit& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      output_mapping_(from.output_mapping_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Emit)
+}
+
+inline void RelCommon_Emit::SharedCtor() {
+}
+
+RelCommon_Emit::~RelCommon_Emit() {
+  // @@protoc_insertion_point(destructor:substrait.RelCommon.Emit)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void RelCommon_Emit::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void RelCommon_Emit::ArenaDtor(void* object) {
+  RelCommon_Emit* _this = reinterpret_cast< RelCommon_Emit* >(object);
+  (void)_this;
+}
+void RelCommon_Emit::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void RelCommon_Emit::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void RelCommon_Emit::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Emit)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  output_mapping_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* RelCommon_Emit::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated int32 output_mapping = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_output_mapping(), ptr, ctx);
+          CHK_(ptr);
+        } else if (static_cast<uint8_t>(tag) == 8) {
+          _internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* RelCommon_Emit::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Emit)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated int32 output_mapping = 1;
+  {
+    int byte_size = _output_mapping_cached_byte_size_.load(std::memory_order_relaxed);
+    if (byte_size > 0) {
+      target = stream->WriteInt32Packed(
+          1, _internal_output_mapping(), byte_size, target);
+    }
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Emit)
+  return target;
+}
+
+size_t RelCommon_Emit::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Emit)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated int32 output_mapping = 1;
+  {
+    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      Int32Size(this->output_mapping_);
+    if (data_size > 0) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+            static_cast<int32_t>(data_size));
+    }
+    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+    _output_mapping_cached_byte_size_.store(cached_size,
+                                    std::memory_order_relaxed);
+    total_size += data_size;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Emit::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    RelCommon_Emit::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Emit::GetClassData() const { return &_class_data_; }
+
+void RelCommon_Emit::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<RelCommon_Emit *>(to)->MergeFrom(
+      static_cast<const RelCommon_Emit &>(from));
+}
+
+
+void RelCommon_Emit::MergeFrom(const RelCommon_Emit& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Emit)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  output_mapping_.MergeFrom(from.output_mapping_);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void RelCommon_Emit::CopyFrom(const RelCommon_Emit& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Emit)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RelCommon_Emit::IsInitialized() const {
+  return true;
+}
+
+void RelCommon_Emit::InternalSwap(RelCommon_Emit* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  output_mapping_.InternalSwap(&other->output_mapping_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Emit::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[1]);
+}
+
+// ===================================================================
+
+class RelCommon_Hint_Stats::_Internal {
+ public:
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint_Stats* msg);
+};
+
+const ::substrait::extensions::AdvancedExtension&
+RelCommon_Hint_Stats::_Internal::advanced_extension(const RelCommon_Hint_Stats* msg) {
+  return *msg->advanced_extension_;
+}
+void RelCommon_Hint_Stats::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+RelCommon_Hint_Stats::RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Hint.Stats)
+}
+RelCommon_Hint_Stats::RelCommon_Hint_Stats(const RelCommon_Hint_Stats& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  ::memcpy(&row_count_, &from.row_count_,
+    static_cast<size_t>(reinterpret_cast<char*>(&record_size_) -
+    reinterpret_cast<char*>(&row_count_)) + sizeof(record_size_));
+  // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint.Stats)
+}
+
+inline void RelCommon_Hint_Stats::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&advanced_extension_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&record_size_) -
+    reinterpret_cast<char*>(&advanced_extension_)) + sizeof(record_size_));
+}
+
+RelCommon_Hint_Stats::~RelCommon_Hint_Stats() {
+  // @@protoc_insertion_point(destructor:substrait.RelCommon.Hint.Stats)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void RelCommon_Hint_Stats::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete advanced_extension_;
+}
+
+void RelCommon_Hint_Stats::ArenaDtor(void* object) {
+  RelCommon_Hint_Stats* _this = reinterpret_cast< RelCommon_Hint_Stats* >(object);
+  (void)_this;
+}
+void RelCommon_Hint_Stats::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void RelCommon_Hint_Stats::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void RelCommon_Hint_Stats::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Hint.Stats)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  ::memset(&row_count_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&record_size_) -
+      reinterpret_cast<char*>(&row_count_)) + sizeof(record_size_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* RelCommon_Hint_Stats::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // double row_count = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 9)) {
+          row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // double record_size = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
+          record_size_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* RelCommon_Hint_Stats::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint.Stats)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // double row_count = 1;
+  static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
+  double tmp_row_count = this->_internal_row_count();
+  uint64_t raw_row_count;
+  memcpy(&raw_row_count, &tmp_row_count, sizeof(tmp_row_count));
+  if (raw_row_count != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_row_count(), target);
+  }
+
+  // double record_size = 2;
+  static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
+  double tmp_record_size = this->_internal_record_size();
+  uint64_t raw_record_size;
+  memcpy(&raw_record_size, &tmp_record_size, sizeof(tmp_record_size));
+  if (raw_record_size != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_record_size(), target);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Hint.Stats)
+  return target;
+}
+
+size_t RelCommon_Hint_Stats::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint.Stats)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  // double row_count = 1;
+  static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
+  double tmp_row_count = this->_internal_row_count();
+  uint64_t raw_row_count;
+  memcpy(&raw_row_count, &tmp_row_count, sizeof(tmp_row_count));
+  if (raw_row_count != 0) {
+    total_size += 1 + 8;
+  }
+
+  // double record_size = 2;
+  static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
+  double tmp_record_size = this->_internal_record_size();
+  uint64_t raw_record_size;
+  memcpy(&raw_record_size, &tmp_record_size, sizeof(tmp_record_size));
+  if (raw_record_size != 0) {
+    total_size += 1 + 8;
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Hint_Stats::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    RelCommon_Hint_Stats::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Hint_Stats::GetClassData() const { return &_class_data_; }
+
+void RelCommon_Hint_Stats::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<RelCommon_Hint_Stats *>(to)->MergeFrom(
+      static_cast<const RelCommon_Hint_Stats &>(from));
+}
+
+
+void RelCommon_Hint_Stats::MergeFrom(const RelCommon_Hint_Stats& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Hint.Stats)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
+  double tmp_row_count = from._internal_row_count();
+  uint64_t raw_row_count;
+  memcpy(&raw_row_count, &tmp_row_count, sizeof(tmp_row_count));
+  if (raw_row_count != 0) {
+    _internal_set_row_count(from._internal_row_count());
+  }
+  static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size.");
+  double tmp_record_size = from._internal_record_size();
+  uint64_t raw_record_size;
+  memcpy(&raw_record_size, &tmp_record_size, sizeof(tmp_record_size));
+  if (raw_record_size != 0) {
+    _internal_set_record_size(from._internal_record_size());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void RelCommon_Hint_Stats::CopyFrom(const RelCommon_Hint_Stats& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Hint.Stats)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RelCommon_Hint_Stats::IsInitialized() const {
+  return true;
+}
+
+void RelCommon_Hint_Stats::InternalSwap(RelCommon_Hint_Stats* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(RelCommon_Hint_Stats, record_size_)
+      + sizeof(RelCommon_Hint_Stats::record_size_)
+      - PROTOBUF_FIELD_OFFSET(RelCommon_Hint_Stats, advanced_extension_)>(
+          reinterpret_cast<char*>(&advanced_extension_),
+          reinterpret_cast<char*>(&other->advanced_extension_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_Stats::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[2]);
+}
+
+// ===================================================================
+
+class RelCommon_Hint_RuntimeConstraint::_Internal {
+ public:
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint_RuntimeConstraint* msg);
+};
+
+const ::substrait::extensions::AdvancedExtension&
+RelCommon_Hint_RuntimeConstraint::_Internal::advanced_extension(const RelCommon_Hint_RuntimeConstraint* msg) {
+  return *msg->advanced_extension_;
+}
+void RelCommon_Hint_RuntimeConstraint::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Hint.RuntimeConstraint)
+}
+RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(const RelCommon_Hint_RuntimeConstraint& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint.RuntimeConstraint)
+}
+
+inline void RelCommon_Hint_RuntimeConstraint::SharedCtor() {
+advanced_extension_ = nullptr;
+}
+
+RelCommon_Hint_RuntimeConstraint::~RelCommon_Hint_RuntimeConstraint() {
+  // @@protoc_insertion_point(destructor:substrait.RelCommon.Hint.RuntimeConstraint)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void RelCommon_Hint_RuntimeConstraint::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete advanced_extension_;
+}
+
+void RelCommon_Hint_RuntimeConstraint::ArenaDtor(void* object) {
+  RelCommon_Hint_RuntimeConstraint* _this = reinterpret_cast< RelCommon_Hint_RuntimeConstraint* >(object);
+  (void)_this;
+}
+void RelCommon_Hint_RuntimeConstraint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void RelCommon_Hint_RuntimeConstraint::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void RelCommon_Hint_RuntimeConstraint::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Hint.RuntimeConstraint)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* RelCommon_Hint_RuntimeConstraint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* RelCommon_Hint_RuntimeConstraint::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint.RuntimeConstraint)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Hint.RuntimeConstraint)
+  return target;
+}
+
+size_t RelCommon_Hint_RuntimeConstraint::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint.RuntimeConstraint)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Hint_RuntimeConstraint::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    RelCommon_Hint_RuntimeConstraint::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Hint_RuntimeConstraint::GetClassData() const { return &_class_data_; }
+
+void RelCommon_Hint_RuntimeConstraint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<RelCommon_Hint_RuntimeConstraint *>(to)->MergeFrom(
+      static_cast<const RelCommon_Hint_RuntimeConstraint &>(from));
+}
+
+
+void RelCommon_Hint_RuntimeConstraint::MergeFrom(const RelCommon_Hint_RuntimeConstraint& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Hint.RuntimeConstraint)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void RelCommon_Hint_RuntimeConstraint::CopyFrom(const RelCommon_Hint_RuntimeConstraint& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Hint.RuntimeConstraint)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RelCommon_Hint_RuntimeConstraint::IsInitialized() const {
+  return true;
+}
+
+void RelCommon_Hint_RuntimeConstraint::InternalSwap(RelCommon_Hint_RuntimeConstraint* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(advanced_extension_, other->advanced_extension_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_RuntimeConstraint::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[3]);
+}
+
+// ===================================================================
+
+class RelCommon_Hint::_Internal {
+ public:
+  static const ::substrait::RelCommon_Hint_Stats& stats(const RelCommon_Hint* msg);
+  static const ::substrait::RelCommon_Hint_RuntimeConstraint& constraint(const RelCommon_Hint* msg);
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint* msg);
+};
+
+const ::substrait::RelCommon_Hint_Stats&
+RelCommon_Hint::_Internal::stats(const RelCommon_Hint* msg) {
+  return *msg->stats_;
+}
+const ::substrait::RelCommon_Hint_RuntimeConstraint&
+RelCommon_Hint::_Internal::constraint(const RelCommon_Hint* msg) {
+  return *msg->constraint_;
+}
+const ::substrait::extensions::AdvancedExtension&
+RelCommon_Hint::_Internal::advanced_extension(const RelCommon_Hint* msg) {
+  return *msg->advanced_extension_;
+}
+void RelCommon_Hint::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+RelCommon_Hint::RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Hint)
+}
+RelCommon_Hint::RelCommon_Hint(const RelCommon_Hint& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_stats()) {
+    stats_ = new ::substrait::RelCommon_Hint_Stats(*from.stats_);
+  } else {
+    stats_ = nullptr;
+  }
+  if (from._internal_has_constraint()) {
+    constraint_ = new ::substrait::RelCommon_Hint_RuntimeConstraint(*from.constraint_);
+  } else {
+    constraint_ = nullptr;
+  }
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint)
+}
+
+inline void RelCommon_Hint::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&stats_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&advanced_extension_) -
+    reinterpret_cast<char*>(&stats_)) + sizeof(advanced_extension_));
+}
+
+RelCommon_Hint::~RelCommon_Hint() {
+  // @@protoc_insertion_point(destructor:substrait.RelCommon.Hint)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void RelCommon_Hint::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete stats_;
+  if (this != internal_default_instance()) delete constraint_;
+  if (this != internal_default_instance()) delete advanced_extension_;
+}
+
+void RelCommon_Hint::ArenaDtor(void* object) {
+  RelCommon_Hint* _this = reinterpret_cast< RelCommon_Hint* >(object);
+  (void)_this;
+}
+void RelCommon_Hint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void RelCommon_Hint::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void RelCommon_Hint::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Hint)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && stats_ != nullptr) {
+    delete stats_;
+  }
+  stats_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && constraint_ != nullptr) {
+    delete constraint_;
+  }
+  constraint_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* RelCommon_Hint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon.Hint.Stats stats = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_stats(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_constraint(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* RelCommon_Hint::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon.Hint.Stats stats = 1;
+  if (this->_internal_has_stats()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::stats(this), target, stream);
+  }
+
+  // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2;
+  if (this->_internal_has_constraint()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::constraint(this), target, stream);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Hint)
+  return target;
+}
+
+size_t RelCommon_Hint::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon.Hint.Stats stats = 1;
+  if (this->_internal_has_stats()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *stats_);
+  }
+
+  // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2;
+  if (this->_internal_has_constraint()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *constraint_);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Hint::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    RelCommon_Hint::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Hint::GetClassData() const { return &_class_data_; }
+
+void RelCommon_Hint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<RelCommon_Hint *>(to)->MergeFrom(
+      static_cast<const RelCommon_Hint &>(from));
+}
+
+
+void RelCommon_Hint::MergeFrom(const RelCommon_Hint& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Hint)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_stats()) {
+    _internal_mutable_stats()->::substrait::RelCommon_Hint_Stats::MergeFrom(from._internal_stats());
+  }
+  if (from._internal_has_constraint()) {
+    _internal_mutable_constraint()->::substrait::RelCommon_Hint_RuntimeConstraint::MergeFrom(from._internal_constraint());
+  }
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void RelCommon_Hint::CopyFrom(const RelCommon_Hint& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Hint)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RelCommon_Hint::IsInitialized() const {
+  return true;
+}
+
+void RelCommon_Hint::InternalSwap(RelCommon_Hint* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(RelCommon_Hint, advanced_extension_)
+      + sizeof(RelCommon_Hint::advanced_extension_)
+      - PROTOBUF_FIELD_OFFSET(RelCommon_Hint, stats_)>(
+          reinterpret_cast<char*>(&stats_),
+          reinterpret_cast<char*>(&other->stats_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[4]);
+}
+
+// ===================================================================
+
+class RelCommon::_Internal {
+ public:
+  static const ::substrait::RelCommon_Direct& direct(const RelCommon* msg);
+  static const ::substrait::RelCommon_Emit& emit(const RelCommon* msg);
+  static const ::substrait::RelCommon_Hint& hint(const RelCommon* msg);
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon* msg);
+};
+
+const ::substrait::RelCommon_Direct&
+RelCommon::_Internal::direct(const RelCommon* msg) {
+  return *msg->emit_kind_.direct_;
+}
+const ::substrait::RelCommon_Emit&
+RelCommon::_Internal::emit(const RelCommon* msg) {
+  return *msg->emit_kind_.emit_;
+}
+const ::substrait::RelCommon_Hint&
+RelCommon::_Internal::hint(const RelCommon* msg) {
+  return *msg->hint_;
+}
+const ::substrait::extensions::AdvancedExtension&
+RelCommon::_Internal::advanced_extension(const RelCommon* msg) {
+  return *msg->advanced_extension_;
+}
+void RelCommon::set_allocated_direct(::substrait::RelCommon_Direct* direct) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_emit_kind();
+  if (direct) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Direct>::GetOwningArena(direct);
+    if (message_arena != submessage_arena) {
+      direct = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, direct, submessage_arena);
+    }
+    set_has_direct();
+    emit_kind_.direct_ = direct;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.direct)
+}
+void RelCommon::set_allocated_emit(::substrait::RelCommon_Emit* emit) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_emit_kind();
+  if (emit) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Emit>::GetOwningArena(emit);
+    if (message_arena != submessage_arena) {
+      emit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, emit, submessage_arena);
+    }
+    set_has_emit();
+    emit_kind_.emit_ = emit;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.emit)
+}
+void RelCommon::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+RelCommon::RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.RelCommon)
+}
+RelCommon::RelCommon(const RelCommon& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_hint()) {
+    hint_ = new ::substrait::RelCommon_Hint(*from.hint_);
+  } else {
+    hint_ = nullptr;
+  }
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  clear_has_emit_kind();
+  switch (from.emit_kind_case()) {
+    case kDirect: {
+      _internal_mutable_direct()->::substrait::RelCommon_Direct::MergeFrom(from._internal_direct());
+      break;
+    }
+    case kEmit: {
+      _internal_mutable_emit()->::substrait::RelCommon_Emit::MergeFrom(from._internal_emit());
+      break;
+    }
+    case EMIT_KIND_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.RelCommon)
+}
+
+inline void RelCommon::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&hint_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&advanced_extension_) -
+    reinterpret_cast<char*>(&hint_)) + sizeof(advanced_extension_));
+clear_has_emit_kind();
+}
+
+RelCommon::~RelCommon() {
+  // @@protoc_insertion_point(destructor:substrait.RelCommon)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void RelCommon::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete hint_;
+  if (this != internal_default_instance()) delete advanced_extension_;
+  if (has_emit_kind()) {
+    clear_emit_kind();
+  }
+}
+
+void RelCommon::ArenaDtor(void* object) {
+  RelCommon* _this = reinterpret_cast< RelCommon* >(object);
+  (void)_this;
+}
+void RelCommon::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void RelCommon::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void RelCommon::clear_emit_kind() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.RelCommon)
+  switch (emit_kind_case()) {
+    case kDirect: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete emit_kind_.direct_;
+      }
+      break;
+    }
+    case kEmit: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete emit_kind_.emit_;
+      }
+      break;
+    }
+    case EMIT_KIND_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = EMIT_KIND_NOT_SET;
+}
+
+
+void RelCommon::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.RelCommon)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && hint_ != nullptr) {
+    delete hint_;
+  }
+  hint_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  clear_emit_kind();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* RelCommon::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon.Direct direct = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_direct(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.RelCommon.Emit emit = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_emit(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.RelCommon.Hint hint = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_hint(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* RelCommon::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon.Direct direct = 1;
+  if (_internal_has_direct()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::direct(this), target, stream);
+  }
+
+  // .substrait.RelCommon.Emit emit = 2;
+  if (_internal_has_emit()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::emit(this), target, stream);
+  }
+
+  // .substrait.RelCommon.Hint hint = 3;
+  if (this->_internal_has_hint()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::hint(this), target, stream);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 4;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon)
+  return target;
+}
+
+size_t RelCommon::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon.Hint hint = 3;
+  if (this->_internal_has_hint()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *hint_);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 4;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  switch (emit_kind_case()) {
+    // .substrait.RelCommon.Direct direct = 1;
+    case kDirect: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *emit_kind_.direct_);
+      break;
+    }
+    // .substrait.RelCommon.Emit emit = 2;
+    case kEmit: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *emit_kind_.emit_);
+      break;
+    }
+    case EMIT_KIND_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    RelCommon::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon::GetClassData() const { return &_class_data_; }
+
+void RelCommon::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<RelCommon *>(to)->MergeFrom(
+      static_cast<const RelCommon &>(from));
+}
+
+
+void RelCommon::MergeFrom(const RelCommon& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_hint()) {
+    _internal_mutable_hint()->::substrait::RelCommon_Hint::MergeFrom(from._internal_hint());
+  }
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  switch (from.emit_kind_case()) {
+    case kDirect: {
+      _internal_mutable_direct()->::substrait::RelCommon_Direct::MergeFrom(from._internal_direct());
+      break;
+    }
+    case kEmit: {
+      _internal_mutable_emit()->::substrait::RelCommon_Emit::MergeFrom(from._internal_emit());
+      break;
+    }
+    case EMIT_KIND_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void RelCommon::CopyFrom(const RelCommon& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RelCommon::IsInitialized() const {
+  return true;
+}
+
+void RelCommon::InternalSwap(RelCommon* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(RelCommon, advanced_extension_)
+      + sizeof(RelCommon::advanced_extension_)
+      - PROTOBUF_FIELD_OFFSET(RelCommon, hint_)>(
+          reinterpret_cast<char*>(&hint_),
+          reinterpret_cast<char*>(&other->hint_));
+  swap(emit_kind_, other->emit_kind_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata RelCommon::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[5]);
+}
+
+// ===================================================================
+
+class ReadRel_NamedTable::_Internal {
+ public:
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel_NamedTable* msg);
+};
+
+const ::substrait::extensions::AdvancedExtension&
+ReadRel_NamedTable::_Internal::advanced_extension(const ReadRel_NamedTable* msg) {
+  return *msg->advanced_extension_;
+}
+void ReadRel_NamedTable::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+ReadRel_NamedTable::ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  names_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.NamedTable)
+}
+ReadRel_NamedTable::ReadRel_NamedTable(const ReadRel_NamedTable& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      names_(from.names_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.NamedTable)
+}
+
+inline void ReadRel_NamedTable::SharedCtor() {
+advanced_extension_ = nullptr;
+}
+
+ReadRel_NamedTable::~ReadRel_NamedTable() {
+  // @@protoc_insertion_point(destructor:substrait.ReadRel.NamedTable)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ReadRel_NamedTable::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete advanced_extension_;
+}
+
+void ReadRel_NamedTable::ArenaDtor(void* object) {
+  ReadRel_NamedTable* _this = reinterpret_cast< ReadRel_NamedTable* >(object);
+  (void)_this;
+}
+void ReadRel_NamedTable::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ReadRel_NamedTable::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ReadRel_NamedTable::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.NamedTable)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  names_.Clear();
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ReadRel_NamedTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated string names = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_names();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.NamedTable.names"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ReadRel_NamedTable::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.NamedTable)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string names = 1;
+  for (int i = 0, n = this->_internal_names_size(); i < n; i++) {
+    const auto& s = this->_internal_names(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.ReadRel.NamedTable.names");
+    target = stream->WriteString(1, s, target);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.NamedTable)
+  return target;
+}
+
+size_t ReadRel_NamedTable::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.NamedTable)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string names = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size());
+  for (int i = 0, n = names_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      names_.Get(i));
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_NamedTable::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ReadRel_NamedTable::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_NamedTable::GetClassData() const { return &_class_data_; }
+
+void ReadRel_NamedTable::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ReadRel_NamedTable *>(to)->MergeFrom(
+      static_cast<const ReadRel_NamedTable &>(from));
+}
+
+
+void ReadRel_NamedTable::MergeFrom(const ReadRel_NamedTable& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.NamedTable)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  names_.MergeFrom(from.names_);
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ReadRel_NamedTable::CopyFrom(const ReadRel_NamedTable& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.NamedTable)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ReadRel_NamedTable::IsInitialized() const {
+  return true;
+}
+
+void ReadRel_NamedTable::InternalSwap(ReadRel_NamedTable* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  names_.InternalSwap(&other->names_);
+  swap(advanced_extension_, other->advanced_extension_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_NamedTable::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[6]);
+}
+
+// ===================================================================
+
+class ReadRel_VirtualTable::_Internal {
+ public:
+};
+
+void ReadRel_VirtualTable::clear_values() {
+  values_.Clear();
+}
+ReadRel_VirtualTable::ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  values_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.VirtualTable)
+}
+ReadRel_VirtualTable::ReadRel_VirtualTable(const ReadRel_VirtualTable& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      values_(from.values_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.VirtualTable)
+}
+
+inline void ReadRel_VirtualTable::SharedCtor() {
+}
+
+ReadRel_VirtualTable::~ReadRel_VirtualTable() {
+  // @@protoc_insertion_point(destructor:substrait.ReadRel.VirtualTable)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ReadRel_VirtualTable::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ReadRel_VirtualTable::ArenaDtor(void* object) {
+  ReadRel_VirtualTable* _this = reinterpret_cast< ReadRel_VirtualTable* >(object);
+  (void)_this;
+}
+void ReadRel_VirtualTable::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ReadRel_VirtualTable::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ReadRel_VirtualTable::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.VirtualTable)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  values_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ReadRel_VirtualTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Expression.Literal.Struct values = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_values(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ReadRel_VirtualTable::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.VirtualTable)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.Literal.Struct values = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_values_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_values(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.VirtualTable)
+  return target;
+}
+
+size_t ReadRel_VirtualTable::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.VirtualTable)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression.Literal.Struct values = 1;
+  total_size += 1UL * this->_internal_values_size();
+  for (const auto& msg : this->values_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_VirtualTable::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ReadRel_VirtualTable::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_VirtualTable::GetClassData() const { return &_class_data_; }
+
+void ReadRel_VirtualTable::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ReadRel_VirtualTable *>(to)->MergeFrom(
+      static_cast<const ReadRel_VirtualTable &>(from));
+}
+
+
+void ReadRel_VirtualTable::MergeFrom(const ReadRel_VirtualTable& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.VirtualTable)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  values_.MergeFrom(from.values_);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ReadRel_VirtualTable::CopyFrom(const ReadRel_VirtualTable& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.VirtualTable)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ReadRel_VirtualTable::IsInitialized() const {
+  return true;
+}
+
+void ReadRel_VirtualTable::InternalSwap(ReadRel_VirtualTable* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  values_.InternalSwap(&other->values_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_VirtualTable::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[7]);
+}
+
+// ===================================================================
+
+class ReadRel_ExtensionTable::_Internal {
+ public:
+  static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ReadRel_ExtensionTable* msg);
+};
+
+const ::PROTOBUF_NAMESPACE_ID::Any&
+ReadRel_ExtensionTable::_Internal::detail(const ReadRel_ExtensionTable* msg) {
+  return *msg->detail_;
+}
+void ReadRel_ExtensionTable::clear_detail() {
+  if (GetArenaForAllocation() == nullptr && detail_ != nullptr) {
+    delete detail_;
+  }
+  detail_ = nullptr;
+}
+ReadRel_ExtensionTable::ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.ExtensionTable)
+}
+ReadRel_ExtensionTable::ReadRel_ExtensionTable(const ReadRel_ExtensionTable& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_detail()) {
+    detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_);
+  } else {
+    detail_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.ExtensionTable)
+}
+
+inline void ReadRel_ExtensionTable::SharedCtor() {
+detail_ = nullptr;
+}
+
+ReadRel_ExtensionTable::~ReadRel_ExtensionTable() {
+  // @@protoc_insertion_point(destructor:substrait.ReadRel.ExtensionTable)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ReadRel_ExtensionTable::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete detail_;
+}
+
+void ReadRel_ExtensionTable::ArenaDtor(void* object) {
+  ReadRel_ExtensionTable* _this = reinterpret_cast< ReadRel_ExtensionTable* >(object);
+  (void)_this;
+}
+void ReadRel_ExtensionTable::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ReadRel_ExtensionTable::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ReadRel_ExtensionTable::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.ExtensionTable)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && detail_ != nullptr) {
+    delete detail_;
+  }
+  detail_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ReadRel_ExtensionTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .google.protobuf.Any detail = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ReadRel_ExtensionTable::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.ExtensionTable)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .google.protobuf.Any detail = 1;
+  if (this->_internal_has_detail()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::detail(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.ExtensionTable)
+  return target;
+}
+
+size_t ReadRel_ExtensionTable::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.ExtensionTable)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .google.protobuf.Any detail = 1;
+  if (this->_internal_has_detail()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *detail_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_ExtensionTable::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ReadRel_ExtensionTable::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_ExtensionTable::GetClassData() const { return &_class_data_; }
+
+void ReadRel_ExtensionTable::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ReadRel_ExtensionTable *>(to)->MergeFrom(
+      static_cast<const ReadRel_ExtensionTable &>(from));
+}
+
+
+void ReadRel_ExtensionTable::MergeFrom(const ReadRel_ExtensionTable& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.ExtensionTable)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_detail()) {
+    _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ReadRel_ExtensionTable::CopyFrom(const ReadRel_ExtensionTable& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.ExtensionTable)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ReadRel_ExtensionTable::IsInitialized() const {
+  return true;
+}
+
+void ReadRel_ExtensionTable::InternalSwap(ReadRel_ExtensionTable* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(detail_, other->detail_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_ExtensionTable::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[8]);
+}
+
+// ===================================================================
+
+class ReadRel_LocalFiles_FileOrFiles::_Internal {
+ public:
+};
+
+ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.LocalFiles.FileOrFiles)
+}
+ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(const ReadRel_LocalFiles_FileOrFiles& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&format_, &from.format_,
+    static_cast<size_t>(reinterpret_cast<char*>(&length_) -
+    reinterpret_cast<char*>(&format_)) + sizeof(length_));
+  clear_has_path_type();
+  switch (from.path_type_case()) {
+    case kUriPath: {
+      _internal_set_uri_path(from._internal_uri_path());
+      break;
+    }
+    case kUriPathGlob: {
+      _internal_set_uri_path_glob(from._internal_uri_path_glob());
+      break;
+    }
+    case kUriFile: {
+      _internal_set_uri_file(from._internal_uri_file());
+      break;
+    }
+    case kUriFolder: {
+      _internal_set_uri_folder(from._internal_uri_folder());
+      break;
+    }
+    case PATH_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.LocalFiles.FileOrFiles)
+}
+
+inline void ReadRel_LocalFiles_FileOrFiles::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&format_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&length_) -
+    reinterpret_cast<char*>(&format_)) + sizeof(length_));
+clear_has_path_type();
+}
+
+ReadRel_LocalFiles_FileOrFiles::~ReadRel_LocalFiles_FileOrFiles() {
+  // @@protoc_insertion_point(destructor:substrait.ReadRel.LocalFiles.FileOrFiles)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ReadRel_LocalFiles_FileOrFiles::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_path_type()) {
+    clear_path_type();
+  }
+}
+
+void ReadRel_LocalFiles_FileOrFiles::ArenaDtor(void* object) {
+  ReadRel_LocalFiles_FileOrFiles* _this = reinterpret_cast< ReadRel_LocalFiles_FileOrFiles* >(object);
+  (void)_this;
+}
+void ReadRel_LocalFiles_FileOrFiles::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ReadRel_LocalFiles_FileOrFiles::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ReadRel_LocalFiles_FileOrFiles::clear_path_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.ReadRel.LocalFiles.FileOrFiles)
+  switch (path_type_case()) {
+    case kUriPath: {
+      path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+      break;
+    }
+    case kUriPathGlob: {
+      path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+      break;
+    }
+    case kUriFile: {
+      path_type_.uri_file_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+      break;
+    }
+    case kUriFolder: {
+      path_type_.uri_folder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+      break;
+    }
+    case PATH_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = PATH_TYPE_NOT_SET;
+}
+
+
+void ReadRel_LocalFiles_FileOrFiles::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.LocalFiles.FileOrFiles)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&format_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&length_) -
+      reinterpret_cast<char*>(&format_)) + sizeof(length_));
+  clear_path_type();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ReadRel_LocalFiles_FileOrFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string uri_path = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_uri_path();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string uri_path_glob = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_uri_path_glob();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string uri_file = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          auto str = _internal_mutable_uri_file();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_file"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string uri_folder = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          auto str = _internal_mutable_uri_folder();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_format(static_cast<::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      // uint64 partition_index = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          partition_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint64 start = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
+          start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint64 length = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
+          length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ReadRel_LocalFiles_FileOrFiles::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.LocalFiles.FileOrFiles)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string uri_path = 1;
+  if (_internal_has_uri_path()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_uri_path().data(), static_cast<int>(this->_internal_uri_path().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_uri_path(), target);
+  }
+
+  // string uri_path_glob = 2;
+  if (_internal_has_uri_path_glob()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_uri_path_glob().data(), static_cast<int>(this->_internal_uri_path_glob().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob");
+    target = stream->WriteStringMaybeAliased(
+        2, this->_internal_uri_path_glob(), target);
+  }
+
+  // string uri_file = 3;
+  if (_internal_has_uri_file()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_uri_file().data(), static_cast<int>(this->_internal_uri_file().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.ReadRel.LocalFiles.FileOrFiles.uri_file");
+    target = stream->WriteStringMaybeAliased(
+        3, this->_internal_uri_file(), target);
+  }
+
+  // string uri_folder = 4;
+  if (_internal_has_uri_folder()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_uri_folder().data(), static_cast<int>(this->_internal_uri_folder().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder");
+    target = stream->WriteStringMaybeAliased(
+        4, this->_internal_uri_folder(), target);
+  }
+
+  // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5;
+  if (this->_internal_format() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      5, this->_internal_format(), target);
+  }
+
+  // uint64 partition_index = 6;
+  if (this->_internal_partition_index() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(6, this->_internal_partition_index(), target);
+  }
+
+  // uint64 start = 7;
+  if (this->_internal_start() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(7, this->_internal_start(), target);
+  }
+
+  // uint64 length = 8;
+  if (this->_internal_length() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(8, this->_internal_length(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.LocalFiles.FileOrFiles)
+  return target;
+}
+
+size_t ReadRel_LocalFiles_FileOrFiles::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.LocalFiles.FileOrFiles)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5;
+  if (this->_internal_format() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_format());
+  }
+
+  // uint64 partition_index = 6;
+  if (this->_internal_partition_index() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_partition_index());
+  }
+
+  // uint64 start = 7;
+  if (this->_internal_start() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_start());
+  }
+
+  // uint64 length = 8;
+  if (this->_internal_length() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_length());
+  }
+
+  switch (path_type_case()) {
+    // string uri_path = 1;
+    case kUriPath: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_uri_path());
+      break;
+    }
+    // string uri_path_glob = 2;
+    case kUriPathGlob: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_uri_path_glob());
+      break;
+    }
+    // string uri_file = 3;
+    case kUriFile: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_uri_file());
+      break;
+    }
+    // string uri_folder = 4;
+    case kUriFolder: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_uri_folder());
+      break;
+    }
+    case PATH_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_LocalFiles_FileOrFiles::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ReadRel_LocalFiles_FileOrFiles::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_LocalFiles_FileOrFiles::GetClassData() const { return &_class_data_; }
+
+void ReadRel_LocalFiles_FileOrFiles::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ReadRel_LocalFiles_FileOrFiles *>(to)->MergeFrom(
+      static_cast<const ReadRel_LocalFiles_FileOrFiles &>(from));
+}
+
+
+void ReadRel_LocalFiles_FileOrFiles::MergeFrom(const ReadRel_LocalFiles_FileOrFiles& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.LocalFiles.FileOrFiles)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_format() != 0) {
+    _internal_set_format(from._internal_format());
+  }
+  if (from._internal_partition_index() != 0) {
+    _internal_set_partition_index(from._internal_partition_index());
+  }
+  if (from._internal_start() != 0) {
+    _internal_set_start(from._internal_start());
+  }
+  if (from._internal_length() != 0) {
+    _internal_set_length(from._internal_length());
+  }
+  switch (from.path_type_case()) {
+    case kUriPath: {
+      _internal_set_uri_path(from._internal_uri_path());
+      break;
+    }
+    case kUriPathGlob: {
+      _internal_set_uri_path_glob(from._internal_uri_path_glob());
+      break;
+    }
+    case kUriFile: {
+      _internal_set_uri_file(from._internal_uri_file());
+      break;
+    }
+    case kUriFolder: {
+      _internal_set_uri_folder(from._internal_uri_folder());
+      break;
+    }
+    case PATH_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ReadRel_LocalFiles_FileOrFiles::CopyFrom(const ReadRel_LocalFiles_FileOrFiles& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.LocalFiles.FileOrFiles)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ReadRel_LocalFiles_FileOrFiles::IsInitialized() const {
+  return true;
+}
+
+void ReadRel_LocalFiles_FileOrFiles::InternalSwap(ReadRel_LocalFiles_FileOrFiles* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ReadRel_LocalFiles_FileOrFiles, length_)
+      + sizeof(ReadRel_LocalFiles_FileOrFiles::length_)
+      - PROTOBUF_FIELD_OFFSET(ReadRel_LocalFiles_FileOrFiles, format_)>(
+          reinterpret_cast<char*>(&format_),
+          reinterpret_cast<char*>(&other->format_));
+  swap(path_type_, other->path_type_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles_FileOrFiles::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[9]);
+}
+
+// ===================================================================
+
+class ReadRel_LocalFiles::_Internal {
+ public:
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel_LocalFiles* msg);
+};
+
+const ::substrait::extensions::AdvancedExtension&
+ReadRel_LocalFiles::_Internal::advanced_extension(const ReadRel_LocalFiles* msg) {
+  return *msg->advanced_extension_;
+}
+void ReadRel_LocalFiles::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+ReadRel_LocalFiles::ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  items_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.LocalFiles)
+}
+ReadRel_LocalFiles::ReadRel_LocalFiles(const ReadRel_LocalFiles& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      items_(from.items_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.LocalFiles)
+}
+
+inline void ReadRel_LocalFiles::SharedCtor() {
+advanced_extension_ = nullptr;
+}
+
+ReadRel_LocalFiles::~ReadRel_LocalFiles() {
+  // @@protoc_insertion_point(destructor:substrait.ReadRel.LocalFiles)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ReadRel_LocalFiles::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete advanced_extension_;
+}
+
+void ReadRel_LocalFiles::ArenaDtor(void* object) {
+  ReadRel_LocalFiles* _this = reinterpret_cast< ReadRel_LocalFiles* >(object);
+  (void)_this;
+}
+void ReadRel_LocalFiles::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ReadRel_LocalFiles::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ReadRel_LocalFiles::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.LocalFiles)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  items_.Clear();
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ReadRel_LocalFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_items(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ReadRel_LocalFiles::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.LocalFiles)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_items_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_items(i), target, stream);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.LocalFiles)
+  return target;
+}
+
+size_t ReadRel_LocalFiles::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.LocalFiles)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1;
+  total_size += 1UL * this->_internal_items_size();
+  for (const auto& msg : this->items_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_LocalFiles::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ReadRel_LocalFiles::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_LocalFiles::GetClassData() const { return &_class_data_; }
+
+void ReadRel_LocalFiles::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ReadRel_LocalFiles *>(to)->MergeFrom(
+      static_cast<const ReadRel_LocalFiles &>(from));
+}
+
+
+void ReadRel_LocalFiles::MergeFrom(const ReadRel_LocalFiles& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.LocalFiles)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  items_.MergeFrom(from.items_);
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ReadRel_LocalFiles::CopyFrom(const ReadRel_LocalFiles& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.LocalFiles)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ReadRel_LocalFiles::IsInitialized() const {
+  return true;
+}
+
+void ReadRel_LocalFiles::InternalSwap(ReadRel_LocalFiles* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  items_.InternalSwap(&other->items_);
+  swap(advanced_extension_, other->advanced_extension_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[10]);
+}
+
+// ===================================================================
+
+class ReadRel::_Internal {
+ public:
+  static const ::substrait::RelCommon& common(const ReadRel* msg);
+  static const ::substrait::NamedStruct& base_schema(const ReadRel* msg);
+  static const ::substrait::Expression& filter(const ReadRel* msg);
+  static const ::substrait::Expression_MaskExpression& projection(const ReadRel* msg);
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel* msg);
+  static const ::substrait::ReadRel_VirtualTable& virtual_table(const ReadRel* msg);
+  static const ::substrait::ReadRel_LocalFiles& local_files(const ReadRel* msg);
+  static const ::substrait::ReadRel_NamedTable& named_table(const ReadRel* msg);
+  static const ::substrait::ReadRel_ExtensionTable& extension_table(const ReadRel* msg);
+};
+
+const ::substrait::RelCommon&
+ReadRel::_Internal::common(const ReadRel* msg) {
+  return *msg->common_;
+}
+const ::substrait::NamedStruct&
+ReadRel::_Internal::base_schema(const ReadRel* msg) {
+  return *msg->base_schema_;
+}
+const ::substrait::Expression&
+ReadRel::_Internal::filter(const ReadRel* msg) {
+  return *msg->filter_;
+}
+const ::substrait::Expression_MaskExpression&
+ReadRel::_Internal::projection(const ReadRel* msg) {
+  return *msg->projection_;
+}
+const ::substrait::extensions::AdvancedExtension&
+ReadRel::_Internal::advanced_extension(const ReadRel* msg) {
+  return *msg->advanced_extension_;
+}
+const ::substrait::ReadRel_VirtualTable&
+ReadRel::_Internal::virtual_table(const ReadRel* msg) {
+  return *msg->read_type_.virtual_table_;
+}
+const ::substrait::ReadRel_LocalFiles&
+ReadRel::_Internal::local_files(const ReadRel* msg) {
+  return *msg->read_type_.local_files_;
+}
+const ::substrait::ReadRel_NamedTable&
+ReadRel::_Internal::named_table(const ReadRel* msg) {
+  return *msg->read_type_.named_table_;
+}
+const ::substrait::ReadRel_ExtensionTable&
+ReadRel::_Internal::extension_table(const ReadRel* msg) {
+  return *msg->read_type_.extension_table_;
+}
+void ReadRel::clear_base_schema() {
+  if (GetArenaForAllocation() == nullptr && base_schema_ != nullptr) {
+    delete base_schema_;
+  }
+  base_schema_ = nullptr;
+}
+void ReadRel::clear_filter() {
+  if (GetArenaForAllocation() == nullptr && filter_ != nullptr) {
+    delete filter_;
+  }
+  filter_ = nullptr;
+}
+void ReadRel::clear_projection() {
+  if (GetArenaForAllocation() == nullptr && projection_ != nullptr) {
+    delete projection_;
+  }
+  projection_ = nullptr;
+}
+void ReadRel::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+void ReadRel::set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* virtual_table) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_read_type();
+  if (virtual_table) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_VirtualTable>::GetOwningArena(virtual_table);
+    if (message_arena != submessage_arena) {
+      virtual_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, virtual_table, submessage_arena);
+    }
+    set_has_virtual_table();
+    read_type_.virtual_table_ = virtual_table;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.virtual_table)
+}
+void ReadRel::set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_files) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_read_type();
+  if (local_files) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_LocalFiles>::GetOwningArena(local_files);
+    if (message_arena != submessage_arena) {
+      local_files = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, local_files, submessage_arena);
+    }
+    set_has_local_files();
+    read_type_.local_files_ = local_files;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.local_files)
+}
+void ReadRel::set_allocated_named_table(::substrait::ReadRel_NamedTable* named_table) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_read_type();
+  if (named_table) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_NamedTable>::GetOwningArena(named_table);
+    if (message_arena != submessage_arena) {
+      named_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, named_table, submessage_arena);
+    }
+    set_has_named_table();
+    read_type_.named_table_ = named_table;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.named_table)
+}
+void ReadRel::set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* extension_table) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_read_type();
+  if (extension_table) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_ExtensionTable>::GetOwningArena(extension_table);
+    if (message_arena != submessage_arena) {
+      extension_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, extension_table, submessage_arena);
+    }
+    set_has_extension_table();
+    read_type_.extension_table_ = extension_table;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.extension_table)
+}
+ReadRel::ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ReadRel)
+}
+ReadRel::ReadRel(const ReadRel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_common()) {
+    common_ = new ::substrait::RelCommon(*from.common_);
+  } else {
+    common_ = nullptr;
+  }
+  if (from._internal_has_base_schema()) {
+    base_schema_ = new ::substrait::NamedStruct(*from.base_schema_);
+  } else {
+    base_schema_ = nullptr;
+  }
+  if (from._internal_has_filter()) {
+    filter_ = new ::substrait::Expression(*from.filter_);
+  } else {
+    filter_ = nullptr;
+  }
+  if (from._internal_has_projection()) {
+    projection_ = new ::substrait::Expression_MaskExpression(*from.projection_);
+  } else {
+    projection_ = nullptr;
+  }
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  clear_has_read_type();
+  switch (from.read_type_case()) {
+    case kVirtualTable: {
+      _internal_mutable_virtual_table()->::substrait::ReadRel_VirtualTable::MergeFrom(from._internal_virtual_table());
+      break;
+    }
+    case kLocalFiles: {
+      _internal_mutable_local_files()->::substrait::ReadRel_LocalFiles::MergeFrom(from._internal_local_files());
+      break;
+    }
+    case kNamedTable: {
+      _internal_mutable_named_table()->::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table());
+      break;
+    }
+    case kExtensionTable: {
+      _internal_mutable_extension_table()->::substrait::ReadRel_ExtensionTable::MergeFrom(from._internal_extension_table());
+      break;
+    }
+    case READ_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ReadRel)
+}
+
+inline void ReadRel::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&common_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&advanced_extension_) -
+    reinterpret_cast<char*>(&common_)) + sizeof(advanced_extension_));
+clear_has_read_type();
+}
+
+ReadRel::~ReadRel() {
+  // @@protoc_insertion_point(destructor:substrait.ReadRel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ReadRel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete common_;
+  if (this != internal_default_instance()) delete base_schema_;
+  if (this != internal_default_instance()) delete filter_;
+  if (this != internal_default_instance()) delete projection_;
+  if (this != internal_default_instance()) delete advanced_extension_;
+  if (has_read_type()) {
+    clear_read_type();
+  }
+}
+
+void ReadRel::ArenaDtor(void* object) {
+  ReadRel* _this = reinterpret_cast< ReadRel* >(object);
+  (void)_this;
+}
+void ReadRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ReadRel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ReadRel::clear_read_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.ReadRel)
+  switch (read_type_case()) {
+    case kVirtualTable: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete read_type_.virtual_table_;
+      }
+      break;
+    }
+    case kLocalFiles: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete read_type_.local_files_;
+      }
+      break;
+    }
+    case kNamedTable: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete read_type_.named_table_;
+      }
+      break;
+    }
+    case kExtensionTable: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete read_type_.extension_table_;
+      }
+      break;
+    }
+    case READ_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = READ_TYPE_NOT_SET;
+}
+
+
+void ReadRel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ReadRel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && base_schema_ != nullptr) {
+    delete base_schema_;
+  }
+  base_schema_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && filter_ != nullptr) {
+    delete filter_;
+  }
+  filter_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && projection_ != nullptr) {
+    delete projection_;
+  }
+  projection_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  clear_read_type();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ReadRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon common = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.NamedStruct base_schema = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_base_schema(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression filter = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression.MaskExpression projection = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_projection(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ReadRel.VirtualTable virtual_table = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_virtual_table(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ReadRel.LocalFiles local_files = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_local_files(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ReadRel.NamedTable named_table = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_named_table(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ReadRel.ExtensionTable extension_table = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_extension_table(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ReadRel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::common(this), target, stream);
+  }
+
+  // .substrait.NamedStruct base_schema = 2;
+  if (this->_internal_has_base_schema()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::base_schema(this), target, stream);
+  }
+
+  // .substrait.Expression filter = 3;
+  if (this->_internal_has_filter()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::filter(this), target, stream);
+  }
+
+  // .substrait.Expression.MaskExpression projection = 4;
+  if (this->_internal_has_projection()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::projection(this), target, stream);
+  }
+
+  // .substrait.ReadRel.VirtualTable virtual_table = 5;
+  if (_internal_has_virtual_table()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        5, _Internal::virtual_table(this), target, stream);
+  }
+
+  // .substrait.ReadRel.LocalFiles local_files = 6;
+  if (_internal_has_local_files()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        6, _Internal::local_files(this), target, stream);
+  }
+
+  // .substrait.ReadRel.NamedTable named_table = 7;
+  if (_internal_has_named_table()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        7, _Internal::named_table(this), target, stream);
+  }
+
+  // .substrait.ReadRel.ExtensionTable extension_table = 8;
+  if (_internal_has_extension_table()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        8, _Internal::extension_table(this), target, stream);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel)
+  return target;
+}
+
+size_t ReadRel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *common_);
+  }
+
+  // .substrait.NamedStruct base_schema = 2;
+  if (this->_internal_has_base_schema()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *base_schema_);
+  }
+
+  // .substrait.Expression filter = 3;
+  if (this->_internal_has_filter()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *filter_);
+  }
+
+  // .substrait.Expression.MaskExpression projection = 4;
+  if (this->_internal_has_projection()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *projection_);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  switch (read_type_case()) {
+    // .substrait.ReadRel.VirtualTable virtual_table = 5;
+    case kVirtualTable: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *read_type_.virtual_table_);
+      break;
+    }
+    // .substrait.ReadRel.LocalFiles local_files = 6;
+    case kLocalFiles: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *read_type_.local_files_);
+      break;
+    }
+    // .substrait.ReadRel.NamedTable named_table = 7;
+    case kNamedTable: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *read_type_.named_table_);
+      break;
+    }
+    // .substrait.ReadRel.ExtensionTable extension_table = 8;
+    case kExtensionTable: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *read_type_.extension_table_);
+      break;
+    }
+    case READ_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ReadRel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel::GetClassData() const { return &_class_data_; }
+
+void ReadRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ReadRel *>(to)->MergeFrom(
+      static_cast<const ReadRel &>(from));
+}
+
+
+void ReadRel::MergeFrom(const ReadRel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_common()) {
+    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
+  }
+  if (from._internal_has_base_schema()) {
+    _internal_mutable_base_schema()->::substrait::NamedStruct::MergeFrom(from._internal_base_schema());
+  }
+  if (from._internal_has_filter()) {
+    _internal_mutable_filter()->::substrait::Expression::MergeFrom(from._internal_filter());
+  }
+  if (from._internal_has_projection()) {
+    _internal_mutable_projection()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_projection());
+  }
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  switch (from.read_type_case()) {
+    case kVirtualTable: {
+      _internal_mutable_virtual_table()->::substrait::ReadRel_VirtualTable::MergeFrom(from._internal_virtual_table());
+      break;
+    }
+    case kLocalFiles: {
+      _internal_mutable_local_files()->::substrait::ReadRel_LocalFiles::MergeFrom(from._internal_local_files());
+      break;
+    }
+    case kNamedTable: {
+      _internal_mutable_named_table()->::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table());
+      break;
+    }
+    case kExtensionTable: {
+      _internal_mutable_extension_table()->::substrait::ReadRel_ExtensionTable::MergeFrom(from._internal_extension_table());
+      break;
+    }
+    case READ_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ReadRel::CopyFrom(const ReadRel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ReadRel::IsInitialized() const {
+  return true;
+}
+
+void ReadRel::InternalSwap(ReadRel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ReadRel, advanced_extension_)
+      + sizeof(ReadRel::advanced_extension_)
+      - PROTOBUF_FIELD_OFFSET(ReadRel, common_)>(
+          reinterpret_cast<char*>(&common_),
+          reinterpret_cast<char*>(&other->common_));
+  swap(read_type_, other->read_type_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ReadRel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[11]);
+}
+
+// ===================================================================
+
+class ProjectRel::_Internal {
+ public:
+  static const ::substrait::RelCommon& common(const ProjectRel* msg);
+  static const ::substrait::Rel& input(const ProjectRel* msg);
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ProjectRel* msg);
+};
+
+const ::substrait::RelCommon&
+ProjectRel::_Internal::common(const ProjectRel* msg) {
+  return *msg->common_;
+}
+const ::substrait::Rel&
+ProjectRel::_Internal::input(const ProjectRel* msg) {
+  return *msg->input_;
+}
+const ::substrait::extensions::AdvancedExtension&
+ProjectRel::_Internal::advanced_extension(const ProjectRel* msg) {
+  return *msg->advanced_extension_;
+}
+void ProjectRel::clear_expressions() {
+  expressions_.Clear();
+}
+void ProjectRel::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+ProjectRel::ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  expressions_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ProjectRel)
+}
+ProjectRel::ProjectRel(const ProjectRel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      expressions_(from.expressions_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_common()) {
+    common_ = new ::substrait::RelCommon(*from.common_);
+  } else {
+    common_ = nullptr;
+  }
+  if (from._internal_has_input()) {
+    input_ = new ::substrait::Rel(*from.input_);
+  } else {
+    input_ = nullptr;
+  }
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ProjectRel)
+}
+
+inline void ProjectRel::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&common_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&advanced_extension_) -
+    reinterpret_cast<char*>(&common_)) + sizeof(advanced_extension_));
+}
+
+ProjectRel::~ProjectRel() {
+  // @@protoc_insertion_point(destructor:substrait.ProjectRel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ProjectRel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete common_;
+  if (this != internal_default_instance()) delete input_;
+  if (this != internal_default_instance()) delete advanced_extension_;
+}
+
+void ProjectRel::ArenaDtor(void* object) {
+  ProjectRel* _this = reinterpret_cast< ProjectRel* >(object);
+  (void)_this;
+}
+void ProjectRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ProjectRel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ProjectRel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ProjectRel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  expressions_.Clear();
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ProjectRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon common = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Rel input = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.Expression expressions = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_expressions(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ProjectRel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ProjectRel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::common(this), target, stream);
+  }
+
+  // .substrait.Rel input = 2;
+  if (this->_internal_has_input()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::input(this), target, stream);
+  }
+
+  // repeated .substrait.Expression expressions = 3;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_expressions_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, this->_internal_expressions(i), target, stream);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ProjectRel)
+  return target;
+}
+
+size_t ProjectRel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ProjectRel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression expressions = 3;
+  total_size += 1UL * this->_internal_expressions_size();
+  for (const auto& msg : this->expressions_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *common_);
+  }
+
+  // .substrait.Rel input = 2;
+  if (this->_internal_has_input()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *input_);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ProjectRel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ProjectRel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ProjectRel::GetClassData() const { return &_class_data_; }
+
+void ProjectRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ProjectRel *>(to)->MergeFrom(
+      static_cast<const ProjectRel &>(from));
+}
+
+
+void ProjectRel::MergeFrom(const ProjectRel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ProjectRel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  expressions_.MergeFrom(from.expressions_);
+  if (from._internal_has_common()) {
+    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
+  }
+  if (from._internal_has_input()) {
+    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
+  }
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ProjectRel::CopyFrom(const ProjectRel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ProjectRel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ProjectRel::IsInitialized() const {
+  return true;
+}
+
+void ProjectRel::InternalSwap(ProjectRel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  expressions_.InternalSwap(&other->expressions_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ProjectRel, advanced_extension_)
+      + sizeof(ProjectRel::advanced_extension_)
+      - PROTOBUF_FIELD_OFFSET(ProjectRel, common_)>(
+          reinterpret_cast<char*>(&common_),
+          reinterpret_cast<char*>(&other->common_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ProjectRel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[12]);
+}
+
+// ===================================================================
+
+class JoinRel::_Internal {
+ public:
+  static const ::substrait::RelCommon& common(const JoinRel* msg);
+  static const ::substrait::Rel& left(const JoinRel* msg);
+  static const ::substrait::Rel& right(const JoinRel* msg);
+  static const ::substrait::Expression& expression(const JoinRel* msg);
+  static const ::substrait::Expression& post_join_filter(const JoinRel* msg);
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const JoinRel* msg);
+};
+
+const ::substrait::RelCommon&
+JoinRel::_Internal::common(const JoinRel* msg) {
+  return *msg->common_;
+}
+const ::substrait::Rel&
+JoinRel::_Internal::left(const JoinRel* msg) {
+  return *msg->left_;
+}
+const ::substrait::Rel&
+JoinRel::_Internal::right(const JoinRel* msg) {
+  return *msg->right_;
+}
+const ::substrait::Expression&
+JoinRel::_Internal::expression(const JoinRel* msg) {
+  return *msg->expression_;
+}
+const ::substrait::Expression&
+JoinRel::_Internal::post_join_filter(const JoinRel* msg) {
+  return *msg->post_join_filter_;
+}
+const ::substrait::extensions::AdvancedExtension&
+JoinRel::_Internal::advanced_extension(const JoinRel* msg) {
+  return *msg->advanced_extension_;
+}
+void JoinRel::clear_expression() {
+  if (GetArenaForAllocation() == nullptr && expression_ != nullptr) {
+    delete expression_;
+  }
+  expression_ = nullptr;
+}
+void JoinRel::clear_post_join_filter() {
+  if (GetArenaForAllocation() == nullptr && post_join_filter_ != nullptr) {
+    delete post_join_filter_;
+  }
+  post_join_filter_ = nullptr;
+}
+void JoinRel::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+JoinRel::JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.JoinRel)
+}
+JoinRel::JoinRel(const JoinRel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_common()) {
+    common_ = new ::substrait::RelCommon(*from.common_);
+  } else {
+    common_ = nullptr;
+  }
+  if (from._internal_has_left()) {
+    left_ = new ::substrait::Rel(*from.left_);
+  } else {
+    left_ = nullptr;
+  }
+  if (from._internal_has_right()) {
+    right_ = new ::substrait::Rel(*from.right_);
+  } else {
+    right_ = nullptr;
+  }
+  if (from._internal_has_expression()) {
+    expression_ = new ::substrait::Expression(*from.expression_);
+  } else {
+    expression_ = nullptr;
+  }
+  if (from._internal_has_post_join_filter()) {
+    post_join_filter_ = new ::substrait::Expression(*from.post_join_filter_);
+  } else {
+    post_join_filter_ = nullptr;
+  }
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  type_ = from.type_;
+  // @@protoc_insertion_point(copy_constructor:substrait.JoinRel)
+}
+
+inline void JoinRel::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&common_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&type_) -
+    reinterpret_cast<char*>(&common_)) + sizeof(type_));
+}
+
+JoinRel::~JoinRel() {
+  // @@protoc_insertion_point(destructor:substrait.JoinRel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void JoinRel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete common_;
+  if (this != internal_default_instance()) delete left_;
+  if (this != internal_default_instance()) delete right_;
+  if (this != internal_default_instance()) delete expression_;
+  if (this != internal_default_instance()) delete post_join_filter_;
+  if (this != internal_default_instance()) delete advanced_extension_;
+}
+
+void JoinRel::ArenaDtor(void* object) {
+  JoinRel* _this = reinterpret_cast< JoinRel* >(object);
+  (void)_this;
+}
+void JoinRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void JoinRel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void JoinRel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.JoinRel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && left_ != nullptr) {
+    delete left_;
+  }
+  left_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && right_ != nullptr) {
+    delete right_;
+  }
+  right_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && expression_ != nullptr) {
+    delete expression_;
+  }
+  expression_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && post_join_filter_ != nullptr) {
+    delete post_join_filter_;
+  }
+  post_join_filter_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  type_ = 0;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* JoinRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon common = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Rel left = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_left(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Rel right = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_right(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression expression = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression post_join_filter = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_post_join_filter(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.JoinRel.JoinType type = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_type(static_cast<::substrait::JoinRel_JoinType>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* JoinRel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.JoinRel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::common(this), target, stream);
+  }
+
+  // .substrait.Rel left = 2;
+  if (this->_internal_has_left()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::left(this), target, stream);
+  }
+
+  // .substrait.Rel right = 3;
+  if (this->_internal_has_right()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::right(this), target, stream);
+  }
+
+  // .substrait.Expression expression = 4;
+  if (this->_internal_has_expression()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::expression(this), target, stream);
+  }
+
+  // .substrait.Expression post_join_filter = 5;
+  if (this->_internal_has_post_join_filter()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        5, _Internal::post_join_filter(this), target, stream);
+  }
+
+  // .substrait.JoinRel.JoinType type = 6;
+  if (this->_internal_type() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      6, this->_internal_type(), target);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.JoinRel)
+  return target;
+}
+
+size_t JoinRel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.JoinRel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *common_);
+  }
+
+  // .substrait.Rel left = 2;
+  if (this->_internal_has_left()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *left_);
+  }
+
+  // .substrait.Rel right = 3;
+  if (this->_internal_has_right()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *right_);
+  }
+
+  // .substrait.Expression expression = 4;
+  if (this->_internal_has_expression()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *expression_);
+  }
+
+  // .substrait.Expression post_join_filter = 5;
+  if (this->_internal_has_post_join_filter()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *post_join_filter_);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  // .substrait.JoinRel.JoinType type = 6;
+  if (this->_internal_type() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData JoinRel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    JoinRel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*JoinRel::GetClassData() const { return &_class_data_; }
+
+void JoinRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<JoinRel *>(to)->MergeFrom(
+      static_cast<const JoinRel &>(from));
+}
+
+
+void JoinRel::MergeFrom(const JoinRel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.JoinRel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_common()) {
+    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
+  }
+  if (from._internal_has_left()) {
+    _internal_mutable_left()->::substrait::Rel::MergeFrom(from._internal_left());
+  }
+  if (from._internal_has_right()) {
+    _internal_mutable_right()->::substrait::Rel::MergeFrom(from._internal_right());
+  }
+  if (from._internal_has_expression()) {
+    _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression());
+  }
+  if (from._internal_has_post_join_filter()) {
+    _internal_mutable_post_join_filter()->::substrait::Expression::MergeFrom(from._internal_post_join_filter());
+  }
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  if (from._internal_type() != 0) {
+    _internal_set_type(from._internal_type());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void JoinRel::CopyFrom(const JoinRel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.JoinRel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool JoinRel::IsInitialized() const {
+  return true;
+}
+
+void JoinRel::InternalSwap(JoinRel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(JoinRel, type_)
+      + sizeof(JoinRel::type_)
+      - PROTOBUF_FIELD_OFFSET(JoinRel, common_)>(
+          reinterpret_cast<char*>(&common_),
+          reinterpret_cast<char*>(&other->common_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata JoinRel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[13]);
+}
+
+// ===================================================================
+
+class FetchRel::_Internal {
+ public:
+  static const ::substrait::RelCommon& common(const FetchRel* msg);
+  static const ::substrait::Rel& input(const FetchRel* msg);
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const FetchRel* msg);
+};
+
+const ::substrait::RelCommon&
+FetchRel::_Internal::common(const FetchRel* msg) {
+  return *msg->common_;
+}
+const ::substrait::Rel&
+FetchRel::_Internal::input(const FetchRel* msg) {
+  return *msg->input_;
+}
+const ::substrait::extensions::AdvancedExtension&
+FetchRel::_Internal::advanced_extension(const FetchRel* msg) {
+  return *msg->advanced_extension_;
+}
+void FetchRel::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+FetchRel::FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.FetchRel)
+}
+FetchRel::FetchRel(const FetchRel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_common()) {
+    common_ = new ::substrait::RelCommon(*from.common_);
+  } else {
+    common_ = nullptr;
+  }
+  if (from._internal_has_input()) {
+    input_ = new ::substrait::Rel(*from.input_);
+  } else {
+    input_ = nullptr;
+  }
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  ::memcpy(&offset_, &from.offset_,
+    static_cast<size_t>(reinterpret_cast<char*>(&count_) -
+    reinterpret_cast<char*>(&offset_)) + sizeof(count_));
+  // @@protoc_insertion_point(copy_constructor:substrait.FetchRel)
+}
+
+inline void FetchRel::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&common_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&count_) -
+    reinterpret_cast<char*>(&common_)) + sizeof(count_));
+}
+
+FetchRel::~FetchRel() {
+  // @@protoc_insertion_point(destructor:substrait.FetchRel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void FetchRel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete common_;
+  if (this != internal_default_instance()) delete input_;
+  if (this != internal_default_instance()) delete advanced_extension_;
+}
+
+void FetchRel::ArenaDtor(void* object) {
+  FetchRel* _this = reinterpret_cast< FetchRel* >(object);
+  (void)_this;
+}
+void FetchRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FetchRel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FetchRel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.FetchRel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  ::memset(&offset_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&count_) -
+      reinterpret_cast<char*>(&offset_)) + sizeof(count_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FetchRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon common = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Rel input = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int64 offset = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int64 count = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FetchRel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.FetchRel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::common(this), target, stream);
+  }
+
+  // .substrait.Rel input = 2;
+  if (this->_internal_has_input()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::input(this), target, stream);
+  }
+
+  // int64 offset = 3;
+  if (this->_internal_offset() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_offset(), target);
+  }
+
+  // int64 count = 4;
+  if (this->_internal_count() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_count(), target);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.FetchRel)
+  return target;
+}
+
+size_t FetchRel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.FetchRel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *common_);
+  }
+
+  // .substrait.Rel input = 2;
+  if (this->_internal_has_input()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *input_);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  // int64 offset = 3;
+  if (this->_internal_offset() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset());
+  }
+
+  // int64 count = 4;
+  if (this->_internal_count() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_count());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FetchRel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    FetchRel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FetchRel::GetClassData() const { return &_class_data_; }
+
+void FetchRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<FetchRel *>(to)->MergeFrom(
+      static_cast<const FetchRel &>(from));
+}
+
+
+void FetchRel::MergeFrom(const FetchRel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FetchRel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_common()) {
+    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
+  }
+  if (from._internal_has_input()) {
+    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
+  }
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  if (from._internal_offset() != 0) {
+    _internal_set_offset(from._internal_offset());
+  }
+  if (from._internal_count() != 0) {
+    _internal_set_count(from._internal_count());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FetchRel::CopyFrom(const FetchRel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FetchRel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FetchRel::IsInitialized() const {
+  return true;
+}
+
+void FetchRel::InternalSwap(FetchRel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(FetchRel, count_)
+      + sizeof(FetchRel::count_)
+      - PROTOBUF_FIELD_OFFSET(FetchRel, common_)>(
+          reinterpret_cast<char*>(&common_),
+          reinterpret_cast<char*>(&other->common_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FetchRel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[14]);
+}
+
+// ===================================================================
+
+class AggregateRel_Grouping::_Internal {
+ public:
+};
+
+void AggregateRel_Grouping::clear_grouping_expressions() {
+  grouping_expressions_.Clear();
+}
+AggregateRel_Grouping::AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  grouping_expressions_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel.Grouping)
+}
+AggregateRel_Grouping::AggregateRel_Grouping(const AggregateRel_Grouping& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      grouping_expressions_(from.grouping_expressions_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel.Grouping)
+}
+
+inline void AggregateRel_Grouping::SharedCtor() {
+}
+
+AggregateRel_Grouping::~AggregateRel_Grouping() {
+  // @@protoc_insertion_point(destructor:substrait.AggregateRel.Grouping)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void AggregateRel_Grouping::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void AggregateRel_Grouping::ArenaDtor(void* object) {
+  AggregateRel_Grouping* _this = reinterpret_cast< AggregateRel_Grouping* >(object);
+  (void)_this;
+}
+void AggregateRel_Grouping::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void AggregateRel_Grouping::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void AggregateRel_Grouping::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.AggregateRel.Grouping)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  grouping_expressions_.Clear();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* AggregateRel_Grouping::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Expression grouping_expressions = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_grouping_expressions(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* AggregateRel_Grouping::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel.Grouping)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression grouping_expressions = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_grouping_expressions_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_grouping_expressions(i), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.AggregateRel.Grouping)
+  return target;
+}
+
+size_t AggregateRel_Grouping::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel.Grouping)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Expression grouping_expressions = 1;
+  total_size += 1UL * this->_internal_grouping_expressions_size();
+  for (const auto& msg : this->grouping_expressions_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateRel_Grouping::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    AggregateRel_Grouping::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateRel_Grouping::GetClassData() const { return &_class_data_; }
+
+void AggregateRel_Grouping::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<AggregateRel_Grouping *>(to)->MergeFrom(
+      static_cast<const AggregateRel_Grouping &>(from));
+}
+
+
+void AggregateRel_Grouping::MergeFrom(const AggregateRel_Grouping& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateRel.Grouping)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  grouping_expressions_.MergeFrom(from.grouping_expressions_);
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void AggregateRel_Grouping::CopyFrom(const AggregateRel_Grouping& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateRel.Grouping)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AggregateRel_Grouping::IsInitialized() const {
+  return true;
+}
+
+void AggregateRel_Grouping::InternalSwap(AggregateRel_Grouping* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  grouping_expressions_.InternalSwap(&other->grouping_expressions_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel_Grouping::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[15]);
+}
+
+// ===================================================================
+
+class AggregateRel_Measure::_Internal {
+ public:
+  static const ::substrait::AggregateFunction& measure(const AggregateRel_Measure* msg);
+  static const ::substrait::Expression& filter(const AggregateRel_Measure* msg);
+};
+
+const ::substrait::AggregateFunction&
+AggregateRel_Measure::_Internal::measure(const AggregateRel_Measure* msg) {
+  return *msg->measure_;
+}
+const ::substrait::Expression&
+AggregateRel_Measure::_Internal::filter(const AggregateRel_Measure* msg) {
+  return *msg->filter_;
+}
+void AggregateRel_Measure::clear_measure() {
+  if (GetArenaForAllocation() == nullptr && measure_ != nullptr) {
+    delete measure_;
+  }
+  measure_ = nullptr;
+}
+void AggregateRel_Measure::clear_filter() {
+  if (GetArenaForAllocation() == nullptr && filter_ != nullptr) {
+    delete filter_;
+  }
+  filter_ = nullptr;
+}
+AggregateRel_Measure::AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel.Measure)
+}
+AggregateRel_Measure::AggregateRel_Measure(const AggregateRel_Measure& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_measure()) {
+    measure_ = new ::substrait::AggregateFunction(*from.measure_);
+  } else {
+    measure_ = nullptr;
+  }
+  if (from._internal_has_filter()) {
+    filter_ = new ::substrait::Expression(*from.filter_);
+  } else {
+    filter_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel.Measure)
+}
+
+inline void AggregateRel_Measure::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&measure_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&filter_) -
+    reinterpret_cast<char*>(&measure_)) + sizeof(filter_));
+}
+
+AggregateRel_Measure::~AggregateRel_Measure() {
+  // @@protoc_insertion_point(destructor:substrait.AggregateRel.Measure)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void AggregateRel_Measure::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete measure_;
+  if (this != internal_default_instance()) delete filter_;
+}
+
+void AggregateRel_Measure::ArenaDtor(void* object) {
+  AggregateRel_Measure* _this = reinterpret_cast< AggregateRel_Measure* >(object);
+  (void)_this;
+}
+void AggregateRel_Measure::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void AggregateRel_Measure::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void AggregateRel_Measure::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.AggregateRel.Measure)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && measure_ != nullptr) {
+    delete measure_;
+  }
+  measure_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && filter_ != nullptr) {
+    delete filter_;
+  }
+  filter_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* AggregateRel_Measure::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.AggregateFunction measure = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_measure(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression filter = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* AggregateRel_Measure::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel.Measure)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.AggregateFunction measure = 1;
+  if (this->_internal_has_measure()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::measure(this), target, stream);
+  }
+
+  // .substrait.Expression filter = 2;
+  if (this->_internal_has_filter()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::filter(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.AggregateRel.Measure)
+  return target;
+}
+
+size_t AggregateRel_Measure::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel.Measure)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.AggregateFunction measure = 1;
+  if (this->_internal_has_measure()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *measure_);
+  }
+
+  // .substrait.Expression filter = 2;
+  if (this->_internal_has_filter()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *filter_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateRel_Measure::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    AggregateRel_Measure::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateRel_Measure::GetClassData() const { return &_class_data_; }
+
+void AggregateRel_Measure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<AggregateRel_Measure *>(to)->MergeFrom(
+      static_cast<const AggregateRel_Measure &>(from));
+}
+
+
+void AggregateRel_Measure::MergeFrom(const AggregateRel_Measure& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateRel.Measure)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_measure()) {
+    _internal_mutable_measure()->::substrait::AggregateFunction::MergeFrom(from._internal_measure());
+  }
+  if (from._internal_has_filter()) {
+    _internal_mutable_filter()->::substrait::Expression::MergeFrom(from._internal_filter());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void AggregateRel_Measure::CopyFrom(const AggregateRel_Measure& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateRel.Measure)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AggregateRel_Measure::IsInitialized() const {
+  return true;
+}
+
+void AggregateRel_Measure::InternalSwap(AggregateRel_Measure* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(AggregateRel_Measure, filter_)
+      + sizeof(AggregateRel_Measure::filter_)
+      - PROTOBUF_FIELD_OFFSET(AggregateRel_Measure, measure_)>(
+          reinterpret_cast<char*>(&measure_),
+          reinterpret_cast<char*>(&other->measure_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel_Measure::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[16]);
+}
+
+// ===================================================================
+
+class AggregateRel::_Internal {
+ public:
+  static const ::substrait::RelCommon& common(const AggregateRel* msg);
+  static const ::substrait::Rel& input(const AggregateRel* msg);
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const AggregateRel* msg);
+};
+
+const ::substrait::RelCommon&
+AggregateRel::_Internal::common(const AggregateRel* msg) {
+  return *msg->common_;
+}
+const ::substrait::Rel&
+AggregateRel::_Internal::input(const AggregateRel* msg) {
+  return *msg->input_;
+}
+const ::substrait::extensions::AdvancedExtension&
+AggregateRel::_Internal::advanced_extension(const AggregateRel* msg) {
+  return *msg->advanced_extension_;
+}
+void AggregateRel::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+AggregateRel::AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  groupings_(arena),
+  measures_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel)
+}
+AggregateRel::AggregateRel(const AggregateRel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      groupings_(from.groupings_),
+      measures_(from.measures_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_common()) {
+    common_ = new ::substrait::RelCommon(*from.common_);
+  } else {
+    common_ = nullptr;
+  }
+  if (from._internal_has_input()) {
+    input_ = new ::substrait::Rel(*from.input_);
+  } else {
+    input_ = nullptr;
+  }
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel)
+}
+
+inline void AggregateRel::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&common_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&advanced_extension_) -
+    reinterpret_cast<char*>(&common_)) + sizeof(advanced_extension_));
+}
+
+AggregateRel::~AggregateRel() {
+  // @@protoc_insertion_point(destructor:substrait.AggregateRel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void AggregateRel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete common_;
+  if (this != internal_default_instance()) delete input_;
+  if (this != internal_default_instance()) delete advanced_extension_;
+}
+
+void AggregateRel::ArenaDtor(void* object) {
+  AggregateRel* _this = reinterpret_cast< AggregateRel* >(object);
+  (void)_this;
+}
+void AggregateRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void AggregateRel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void AggregateRel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.AggregateRel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  groupings_.Clear();
+  measures_.Clear();
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* AggregateRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon common = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Rel input = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.AggregateRel.Grouping groupings = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_groupings(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.AggregateRel.Measure measures = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_measures(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* AggregateRel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::common(this), target, stream);
+  }
+
+  // .substrait.Rel input = 2;
+  if (this->_internal_has_input()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::input(this), target, stream);
+  }
+
+  // repeated .substrait.AggregateRel.Grouping groupings = 3;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_groupings_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, this->_internal_groupings(i), target, stream);
+  }
+
+  // repeated .substrait.AggregateRel.Measure measures = 4;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_measures_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(4, this->_internal_measures(i), target, stream);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.AggregateRel)
+  return target;
+}
+
+size_t AggregateRel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.AggregateRel.Grouping groupings = 3;
+  total_size += 1UL * this->_internal_groupings_size();
+  for (const auto& msg : this->groupings_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .substrait.AggregateRel.Measure measures = 4;
+  total_size += 1UL * this->_internal_measures_size();
+  for (const auto& msg : this->measures_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *common_);
+  }
+
+  // .substrait.Rel input = 2;
+  if (this->_internal_has_input()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *input_);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateRel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    AggregateRel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateRel::GetClassData() const { return &_class_data_; }
+
+void AggregateRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<AggregateRel *>(to)->MergeFrom(
+      static_cast<const AggregateRel &>(from));
+}
+
+
+void AggregateRel::MergeFrom(const AggregateRel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateRel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  groupings_.MergeFrom(from.groupings_);
+  measures_.MergeFrom(from.measures_);
+  if (from._internal_has_common()) {
+    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
+  }
+  if (from._internal_has_input()) {
+    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
+  }
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void AggregateRel::CopyFrom(const AggregateRel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateRel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AggregateRel::IsInitialized() const {
+  return true;
+}
+
+void AggregateRel::InternalSwap(AggregateRel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  groupings_.InternalSwap(&other->groupings_);
+  measures_.InternalSwap(&other->measures_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(AggregateRel, advanced_extension_)
+      + sizeof(AggregateRel::advanced_extension_)
+      - PROTOBUF_FIELD_OFFSET(AggregateRel, common_)>(
+          reinterpret_cast<char*>(&common_),
+          reinterpret_cast<char*>(&other->common_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[17]);
+}
+
+// ===================================================================
+
+class SortRel::_Internal {
+ public:
+  static const ::substrait::RelCommon& common(const SortRel* msg);
+  static const ::substrait::Rel& input(const SortRel* msg);
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const SortRel* msg);
+};
+
+const ::substrait::RelCommon&
+SortRel::_Internal::common(const SortRel* msg) {
+  return *msg->common_;
+}
+const ::substrait::Rel&
+SortRel::_Internal::input(const SortRel* msg) {
+  return *msg->input_;
+}
+const ::substrait::extensions::AdvancedExtension&
+SortRel::_Internal::advanced_extension(const SortRel* msg) {
+  return *msg->advanced_extension_;
+}
+void SortRel::clear_sorts() {
+  sorts_.Clear();
+}
+void SortRel::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+SortRel::SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  sorts_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.SortRel)
+}
+SortRel::SortRel(const SortRel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      sorts_(from.sorts_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_common()) {
+    common_ = new ::substrait::RelCommon(*from.common_);
+  } else {
+    common_ = nullptr;
+  }
+  if (from._internal_has_input()) {
+    input_ = new ::substrait::Rel(*from.input_);
+  } else {
+    input_ = nullptr;
+  }
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.SortRel)
+}
+
+inline void SortRel::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&common_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&advanced_extension_) -
+    reinterpret_cast<char*>(&common_)) + sizeof(advanced_extension_));
+}
+
+SortRel::~SortRel() {
+  // @@protoc_insertion_point(destructor:substrait.SortRel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void SortRel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete common_;
+  if (this != internal_default_instance()) delete input_;
+  if (this != internal_default_instance()) delete advanced_extension_;
+}
+
+void SortRel::ArenaDtor(void* object) {
+  SortRel* _this = reinterpret_cast< SortRel* >(object);
+  (void)_this;
+}
+void SortRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void SortRel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void SortRel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.SortRel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  sorts_.Clear();
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SortRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon common = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Rel input = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.SortField sorts = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_sorts(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SortRel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.SortRel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::common(this), target, stream);
+  }
+
+  // .substrait.Rel input = 2;
+  if (this->_internal_has_input()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::input(this), target, stream);
+  }
+
+  // repeated .substrait.SortField sorts = 3;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_sorts_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(3, this->_internal_sorts(i), target, stream);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.SortRel)
+  return target;
+}
+
+size_t SortRel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.SortRel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.SortField sorts = 3;
+  total_size += 1UL * this->_internal_sorts_size();
+  for (const auto& msg : this->sorts_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *common_);
+  }
+
+  // .substrait.Rel input = 2;
+  if (this->_internal_has_input()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *input_);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SortRel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    SortRel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SortRel::GetClassData() const { return &_class_data_; }
+
+void SortRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<SortRel *>(to)->MergeFrom(
+      static_cast<const SortRel &>(from));
+}
+
+
+void SortRel::MergeFrom(const SortRel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.SortRel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  sorts_.MergeFrom(from.sorts_);
+  if (from._internal_has_common()) {
+    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
+  }
+  if (from._internal_has_input()) {
+    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
+  }
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SortRel::CopyFrom(const SortRel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.SortRel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SortRel::IsInitialized() const {
+  return true;
+}
+
+void SortRel::InternalSwap(SortRel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  sorts_.InternalSwap(&other->sorts_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SortRel, advanced_extension_)
+      + sizeof(SortRel::advanced_extension_)
+      - PROTOBUF_FIELD_OFFSET(SortRel, common_)>(
+          reinterpret_cast<char*>(&common_),
+          reinterpret_cast<char*>(&other->common_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SortRel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[18]);
+}
+
+// ===================================================================
+
+class FilterRel::_Internal {
+ public:
+  static const ::substrait::RelCommon& common(const FilterRel* msg);
+  static const ::substrait::Rel& input(const FilterRel* msg);
+  static const ::substrait::Expression& condition(const FilterRel* msg);
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const FilterRel* msg);
+};
+
+const ::substrait::RelCommon&
+FilterRel::_Internal::common(const FilterRel* msg) {
+  return *msg->common_;
+}
+const ::substrait::Rel&
+FilterRel::_Internal::input(const FilterRel* msg) {
+  return *msg->input_;
+}
+const ::substrait::Expression&
+FilterRel::_Internal::condition(const FilterRel* msg) {
+  return *msg->condition_;
+}
+const ::substrait::extensions::AdvancedExtension&
+FilterRel::_Internal::advanced_extension(const FilterRel* msg) {
+  return *msg->advanced_extension_;
+}
+void FilterRel::clear_condition() {
+  if (GetArenaForAllocation() == nullptr && condition_ != nullptr) {
+    delete condition_;
+  }
+  condition_ = nullptr;
+}
+void FilterRel::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+FilterRel::FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.FilterRel)
+}
+FilterRel::FilterRel(const FilterRel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_common()) {
+    common_ = new ::substrait::RelCommon(*from.common_);
+  } else {
+    common_ = nullptr;
+  }
+  if (from._internal_has_input()) {
+    input_ = new ::substrait::Rel(*from.input_);
+  } else {
+    input_ = nullptr;
+  }
+  if (from._internal_has_condition()) {
+    condition_ = new ::substrait::Expression(*from.condition_);
+  } else {
+    condition_ = nullptr;
+  }
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.FilterRel)
+}
+
+inline void FilterRel::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&common_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&advanced_extension_) -
+    reinterpret_cast<char*>(&common_)) + sizeof(advanced_extension_));
+}
+
+FilterRel::~FilterRel() {
+  // @@protoc_insertion_point(destructor:substrait.FilterRel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void FilterRel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete common_;
+  if (this != internal_default_instance()) delete input_;
+  if (this != internal_default_instance()) delete condition_;
+  if (this != internal_default_instance()) delete advanced_extension_;
+}
+
+void FilterRel::ArenaDtor(void* object) {
+  FilterRel* _this = reinterpret_cast< FilterRel* >(object);
+  (void)_this;
+}
+void FilterRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void FilterRel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void FilterRel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.FilterRel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && condition_ != nullptr) {
+    delete condition_;
+  }
+  condition_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* FilterRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon common = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Rel input = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Expression condition = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_condition(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* FilterRel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.FilterRel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::common(this), target, stream);
+  }
+
+  // .substrait.Rel input = 2;
+  if (this->_internal_has_input()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::input(this), target, stream);
+  }
+
+  // .substrait.Expression condition = 3;
+  if (this->_internal_has_condition()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::condition(this), target, stream);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.FilterRel)
+  return target;
+}
+
+size_t FilterRel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.FilterRel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *common_);
+  }
+
+  // .substrait.Rel input = 2;
+  if (this->_internal_has_input()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *input_);
+  }
+
+  // .substrait.Expression condition = 3;
+  if (this->_internal_has_condition()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *condition_);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FilterRel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    FilterRel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FilterRel::GetClassData() const { return &_class_data_; }
+
+void FilterRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<FilterRel *>(to)->MergeFrom(
+      static_cast<const FilterRel &>(from));
+}
+
+
+void FilterRel::MergeFrom(const FilterRel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FilterRel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_common()) {
+    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
+  }
+  if (from._internal_has_input()) {
+    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
+  }
+  if (from._internal_has_condition()) {
+    _internal_mutable_condition()->::substrait::Expression::MergeFrom(from._internal_condition());
+  }
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void FilterRel::CopyFrom(const FilterRel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FilterRel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FilterRel::IsInitialized() const {
+  return true;
+}
+
+void FilterRel::InternalSwap(FilterRel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(FilterRel, advanced_extension_)
+      + sizeof(FilterRel::advanced_extension_)
+      - PROTOBUF_FIELD_OFFSET(FilterRel, common_)>(
+          reinterpret_cast<char*>(&common_),
+          reinterpret_cast<char*>(&other->common_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata FilterRel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[19]);
+}
+
+// ===================================================================
+
+class SetRel::_Internal {
+ public:
+  static const ::substrait::RelCommon& common(const SetRel* msg);
+  static const ::substrait::extensions::AdvancedExtension& advanced_extension(const SetRel* msg);
+};
+
+const ::substrait::RelCommon&
+SetRel::_Internal::common(const SetRel* msg) {
+  return *msg->common_;
+}
+const ::substrait::extensions::AdvancedExtension&
+SetRel::_Internal::advanced_extension(const SetRel* msg) {
+  return *msg->advanced_extension_;
+}
+void SetRel::clear_advanced_extension() {
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+}
+SetRel::SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  inputs_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.SetRel)
+}
+SetRel::SetRel(const SetRel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      inputs_(from.inputs_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_common()) {
+    common_ = new ::substrait::RelCommon(*from.common_);
+  } else {
+    common_ = nullptr;
+  }
+  if (from._internal_has_advanced_extension()) {
+    advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_);
+  } else {
+    advanced_extension_ = nullptr;
+  }
+  op_ = from.op_;
+  // @@protoc_insertion_point(copy_constructor:substrait.SetRel)
+}
+
+inline void SetRel::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&common_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&op_) -
+    reinterpret_cast<char*>(&common_)) + sizeof(op_));
+}
+
+SetRel::~SetRel() {
+  // @@protoc_insertion_point(destructor:substrait.SetRel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void SetRel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete common_;
+  if (this != internal_default_instance()) delete advanced_extension_;
+}
+
+void SetRel::ArenaDtor(void* object) {
+  SetRel* _this = reinterpret_cast< SetRel* >(object);
+  (void)_this;
+}
+void SetRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void SetRel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void SetRel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.SetRel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  inputs_.Clear();
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) {
+    delete advanced_extension_;
+  }
+  advanced_extension_ = nullptr;
+  op_ = 0;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* SetRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon common = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.Rel inputs = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_inputs(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.SetRel.SetOp op = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_op(static_cast<::substrait::SetRel_SetOp>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* SetRel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.SetRel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::common(this), target, stream);
+  }
+
+  // repeated .substrait.Rel inputs = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_inputs_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_inputs(i), target, stream);
+  }
+
+  // .substrait.SetRel.SetOp op = 3;
+  if (this->_internal_op() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_op(), target);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::advanced_extension(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.SetRel)
+  return target;
+}
+
+size_t SetRel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.SetRel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Rel inputs = 2;
+  total_size += 1UL * this->_internal_inputs_size();
+  for (const auto& msg : this->inputs_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *common_);
+  }
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  if (this->_internal_has_advanced_extension()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *advanced_extension_);
+  }
+
+  // .substrait.SetRel.SetOp op = 3;
+  if (this->_internal_op() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SetRel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    SetRel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SetRel::GetClassData() const { return &_class_data_; }
+
+void SetRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<SetRel *>(to)->MergeFrom(
+      static_cast<const SetRel &>(from));
+}
+
+
+void SetRel::MergeFrom(const SetRel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.SetRel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  inputs_.MergeFrom(from.inputs_);
+  if (from._internal_has_common()) {
+    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
+  }
+  if (from._internal_has_advanced_extension()) {
+    _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension());
+  }
+  if (from._internal_op() != 0) {
+    _internal_set_op(from._internal_op());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void SetRel::CopyFrom(const SetRel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.SetRel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SetRel::IsInitialized() const {
+  return true;
+}
+
+void SetRel::InternalSwap(SetRel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  inputs_.InternalSwap(&other->inputs_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(SetRel, op_)
+      + sizeof(SetRel::op_)
+      - PROTOBUF_FIELD_OFFSET(SetRel, common_)>(
+          reinterpret_cast<char*>(&common_),
+          reinterpret_cast<char*>(&other->common_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SetRel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[20]);
+}
+
+// ===================================================================
+
+class ExtensionSingleRel::_Internal {
+ public:
+  static const ::substrait::RelCommon& common(const ExtensionSingleRel* msg);
+  static const ::substrait::Rel& input(const ExtensionSingleRel* msg);
+  static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionSingleRel* msg);
+};
+
+const ::substrait::RelCommon&
+ExtensionSingleRel::_Internal::common(const ExtensionSingleRel* msg) {
+  return *msg->common_;
+}
+const ::substrait::Rel&
+ExtensionSingleRel::_Internal::input(const ExtensionSingleRel* msg) {
+  return *msg->input_;
+}
+const ::PROTOBUF_NAMESPACE_ID::Any&
+ExtensionSingleRel::_Internal::detail(const ExtensionSingleRel* msg) {
+  return *msg->detail_;
+}
+void ExtensionSingleRel::clear_detail() {
+  if (GetArenaForAllocation() == nullptr && detail_ != nullptr) {
+    delete detail_;
+  }
+  detail_ = nullptr;
+}
+ExtensionSingleRel::ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ExtensionSingleRel)
+}
+ExtensionSingleRel::ExtensionSingleRel(const ExtensionSingleRel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_common()) {
+    common_ = new ::substrait::RelCommon(*from.common_);
+  } else {
+    common_ = nullptr;
+  }
+  if (from._internal_has_input()) {
+    input_ = new ::substrait::Rel(*from.input_);
+  } else {
+    input_ = nullptr;
+  }
+  if (from._internal_has_detail()) {
+    detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_);
+  } else {
+    detail_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ExtensionSingleRel)
+}
+
+inline void ExtensionSingleRel::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&common_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&detail_) -
+    reinterpret_cast<char*>(&common_)) + sizeof(detail_));
+}
+
+ExtensionSingleRel::~ExtensionSingleRel() {
+  // @@protoc_insertion_point(destructor:substrait.ExtensionSingleRel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ExtensionSingleRel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete common_;
+  if (this != internal_default_instance()) delete input_;
+  if (this != internal_default_instance()) delete detail_;
+}
+
+void ExtensionSingleRel::ArenaDtor(void* object) {
+  ExtensionSingleRel* _this = reinterpret_cast< ExtensionSingleRel* >(object);
+  (void)_this;
+}
+void ExtensionSingleRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ExtensionSingleRel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ExtensionSingleRel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ExtensionSingleRel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && detail_ != nullptr) {
+    delete detail_;
+  }
+  detail_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ExtensionSingleRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon common = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Rel input = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .google.protobuf.Any detail = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ExtensionSingleRel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionSingleRel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::common(this), target, stream);
+  }
+
+  // .substrait.Rel input = 2;
+  if (this->_internal_has_input()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::input(this), target, stream);
+  }
+
+  // .google.protobuf.Any detail = 3;
+  if (this->_internal_has_detail()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::detail(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ExtensionSingleRel)
+  return target;
+}
+
+size_t ExtensionSingleRel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionSingleRel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *common_);
+  }
+
+  // .substrait.Rel input = 2;
+  if (this->_internal_has_input()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *input_);
+  }
+
+  // .google.protobuf.Any detail = 3;
+  if (this->_internal_has_detail()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *detail_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExtensionSingleRel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ExtensionSingleRel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExtensionSingleRel::GetClassData() const { return &_class_data_; }
+
+void ExtensionSingleRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ExtensionSingleRel *>(to)->MergeFrom(
+      static_cast<const ExtensionSingleRel &>(from));
+}
+
+
+void ExtensionSingleRel::MergeFrom(const ExtensionSingleRel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ExtensionSingleRel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_common()) {
+    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
+  }
+  if (from._internal_has_input()) {
+    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
+  }
+  if (from._internal_has_detail()) {
+    _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ExtensionSingleRel::CopyFrom(const ExtensionSingleRel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ExtensionSingleRel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ExtensionSingleRel::IsInitialized() const {
+  return true;
+}
+
+void ExtensionSingleRel::InternalSwap(ExtensionSingleRel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ExtensionSingleRel, detail_)
+      + sizeof(ExtensionSingleRel::detail_)
+      - PROTOBUF_FIELD_OFFSET(ExtensionSingleRel, common_)>(
+          reinterpret_cast<char*>(&common_),
+          reinterpret_cast<char*>(&other->common_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ExtensionSingleRel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[21]);
+}
+
+// ===================================================================
+
+class ExtensionLeafRel::_Internal {
+ public:
+  static const ::substrait::RelCommon& common(const ExtensionLeafRel* msg);
+  static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionLeafRel* msg);
+};
+
+const ::substrait::RelCommon&
+ExtensionLeafRel::_Internal::common(const ExtensionLeafRel* msg) {
+  return *msg->common_;
+}
+const ::PROTOBUF_NAMESPACE_ID::Any&
+ExtensionLeafRel::_Internal::detail(const ExtensionLeafRel* msg) {
+  return *msg->detail_;
+}
+void ExtensionLeafRel::clear_detail() {
+  if (GetArenaForAllocation() == nullptr && detail_ != nullptr) {
+    delete detail_;
+  }
+  detail_ = nullptr;
+}
+ExtensionLeafRel::ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ExtensionLeafRel)
+}
+ExtensionLeafRel::ExtensionLeafRel(const ExtensionLeafRel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_common()) {
+    common_ = new ::substrait::RelCommon(*from.common_);
+  } else {
+    common_ = nullptr;
+  }
+  if (from._internal_has_detail()) {
+    detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_);
+  } else {
+    detail_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ExtensionLeafRel)
+}
+
+inline void ExtensionLeafRel::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&common_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&detail_) -
+    reinterpret_cast<char*>(&common_)) + sizeof(detail_));
+}
+
+ExtensionLeafRel::~ExtensionLeafRel() {
+  // @@protoc_insertion_point(destructor:substrait.ExtensionLeafRel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ExtensionLeafRel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete common_;
+  if (this != internal_default_instance()) delete detail_;
+}
+
+void ExtensionLeafRel::ArenaDtor(void* object) {
+  ExtensionLeafRel* _this = reinterpret_cast< ExtensionLeafRel* >(object);
+  (void)_this;
+}
+void ExtensionLeafRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ExtensionLeafRel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ExtensionLeafRel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ExtensionLeafRel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && detail_ != nullptr) {
+    delete detail_;
+  }
+  detail_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ExtensionLeafRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon common = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .google.protobuf.Any detail = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ExtensionLeafRel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionLeafRel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::common(this), target, stream);
+  }
+
+  // .google.protobuf.Any detail = 2;
+  if (this->_internal_has_detail()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::detail(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ExtensionLeafRel)
+  return target;
+}
+
+size_t ExtensionLeafRel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionLeafRel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *common_);
+  }
+
+  // .google.protobuf.Any detail = 2;
+  if (this->_internal_has_detail()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *detail_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExtensionLeafRel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ExtensionLeafRel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExtensionLeafRel::GetClassData() const { return &_class_data_; }
+
+void ExtensionLeafRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ExtensionLeafRel *>(to)->MergeFrom(
+      static_cast<const ExtensionLeafRel &>(from));
+}
+
+
+void ExtensionLeafRel::MergeFrom(const ExtensionLeafRel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ExtensionLeafRel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_common()) {
+    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
+  }
+  if (from._internal_has_detail()) {
+    _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ExtensionLeafRel::CopyFrom(const ExtensionLeafRel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ExtensionLeafRel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ExtensionLeafRel::IsInitialized() const {
+  return true;
+}
+
+void ExtensionLeafRel::InternalSwap(ExtensionLeafRel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ExtensionLeafRel, detail_)
+      + sizeof(ExtensionLeafRel::detail_)
+      - PROTOBUF_FIELD_OFFSET(ExtensionLeafRel, common_)>(
+          reinterpret_cast<char*>(&common_),
+          reinterpret_cast<char*>(&other->common_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ExtensionLeafRel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[22]);
+}
+
+// ===================================================================
+
+class ExtensionMultiRel::_Internal {
+ public:
+  static const ::substrait::RelCommon& common(const ExtensionMultiRel* msg);
+  static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionMultiRel* msg);
+};
+
+const ::substrait::RelCommon&
+ExtensionMultiRel::_Internal::common(const ExtensionMultiRel* msg) {
+  return *msg->common_;
+}
+const ::PROTOBUF_NAMESPACE_ID::Any&
+ExtensionMultiRel::_Internal::detail(const ExtensionMultiRel* msg) {
+  return *msg->detail_;
+}
+void ExtensionMultiRel::clear_detail() {
+  if (GetArenaForAllocation() == nullptr && detail_ != nullptr) {
+    delete detail_;
+  }
+  detail_ = nullptr;
+}
+ExtensionMultiRel::ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  inputs_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.ExtensionMultiRel)
+}
+ExtensionMultiRel::ExtensionMultiRel(const ExtensionMultiRel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      inputs_(from.inputs_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_common()) {
+    common_ = new ::substrait::RelCommon(*from.common_);
+  } else {
+    common_ = nullptr;
+  }
+  if (from._internal_has_detail()) {
+    detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_);
+  } else {
+    detail_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.ExtensionMultiRel)
+}
+
+inline void ExtensionMultiRel::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&common_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&detail_) -
+    reinterpret_cast<char*>(&common_)) + sizeof(detail_));
+}
+
+ExtensionMultiRel::~ExtensionMultiRel() {
+  // @@protoc_insertion_point(destructor:substrait.ExtensionMultiRel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ExtensionMultiRel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete common_;
+  if (this != internal_default_instance()) delete detail_;
+}
+
+void ExtensionMultiRel::ArenaDtor(void* object) {
+  ExtensionMultiRel* _this = reinterpret_cast< ExtensionMultiRel* >(object);
+  (void)_this;
+}
+void ExtensionMultiRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ExtensionMultiRel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void ExtensionMultiRel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.ExtensionMultiRel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  inputs_.Clear();
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && detail_ != nullptr) {
+    delete detail_;
+  }
+  detail_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ExtensionMultiRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.RelCommon common = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_common(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated .substrait.Rel inputs = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_inputs(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .google.protobuf.Any detail = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* ExtensionMultiRel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionMultiRel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::common(this), target, stream);
+  }
+
+  // repeated .substrait.Rel inputs = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_inputs_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_inputs(i), target, stream);
+  }
+
+  // .google.protobuf.Any detail = 3;
+  if (this->_internal_has_detail()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::detail(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.ExtensionMultiRel)
+  return target;
+}
+
+size_t ExtensionMultiRel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionMultiRel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Rel inputs = 2;
+  total_size += 1UL * this->_internal_inputs_size();
+  for (const auto& msg : this->inputs_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.RelCommon common = 1;
+  if (this->_internal_has_common()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *common_);
+  }
+
+  // .google.protobuf.Any detail = 3;
+  if (this->_internal_has_detail()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *detail_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExtensionMultiRel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    ExtensionMultiRel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExtensionMultiRel::GetClassData() const { return &_class_data_; }
+
+void ExtensionMultiRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<ExtensionMultiRel *>(to)->MergeFrom(
+      static_cast<const ExtensionMultiRel &>(from));
+}
+
+
+void ExtensionMultiRel::MergeFrom(const ExtensionMultiRel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ExtensionMultiRel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  inputs_.MergeFrom(from.inputs_);
+  if (from._internal_has_common()) {
+    _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common());
+  }
+  if (from._internal_has_detail()) {
+    _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ExtensionMultiRel::CopyFrom(const ExtensionMultiRel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ExtensionMultiRel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ExtensionMultiRel::IsInitialized() const {
+  return true;
+}
+
+void ExtensionMultiRel::InternalSwap(ExtensionMultiRel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  inputs_.InternalSwap(&other->inputs_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(ExtensionMultiRel, detail_)
+      + sizeof(ExtensionMultiRel::detail_)
+      - PROTOBUF_FIELD_OFFSET(ExtensionMultiRel, common_)>(
+          reinterpret_cast<char*>(&common_),
+          reinterpret_cast<char*>(&other->common_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ExtensionMultiRel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[23]);
+}
+
+// ===================================================================
+
+class RelRoot::_Internal {
+ public:
+  static const ::substrait::Rel& input(const RelRoot* msg);
+};
+
+const ::substrait::Rel&
+RelRoot::_Internal::input(const RelRoot* msg) {
+  return *msg->input_;
+}
+RelRoot::RelRoot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  names_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.RelRoot)
+}
+RelRoot::RelRoot(const RelRoot& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      names_(from.names_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_input()) {
+    input_ = new ::substrait::Rel(*from.input_);
+  } else {
+    input_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.RelRoot)
+}
+
+inline void RelRoot::SharedCtor() {
+input_ = nullptr;
+}
+
+RelRoot::~RelRoot() {
+  // @@protoc_insertion_point(destructor:substrait.RelRoot)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void RelRoot::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete input_;
+}
+
+void RelRoot::ArenaDtor(void* object) {
+  RelRoot* _this = reinterpret_cast< RelRoot* >(object);
+  (void)_this;
+}
+void RelRoot::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void RelRoot::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void RelRoot::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.RelRoot)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  names_.Clear();
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* RelRoot::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Rel input = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_input(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // repeated string names = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_names();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.RelRoot.names"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* RelRoot::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.RelRoot)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Rel input = 1;
+  if (this->_internal_has_input()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::input(this), target, stream);
+  }
+
+  // repeated string names = 2;
+  for (int i = 0, n = this->_internal_names_size(); i < n; i++) {
+    const auto& s = this->_internal_names(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.RelRoot.names");
+    target = stream->WriteString(2, s, target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.RelRoot)
+  return target;
+}
+
+size_t RelRoot::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.RelRoot)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string names = 2;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size());
+  for (int i = 0, n = names_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      names_.Get(i));
+  }
+
+  // .substrait.Rel input = 1;
+  if (this->_internal_has_input()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *input_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelRoot::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    RelRoot::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelRoot::GetClassData() const { return &_class_data_; }
+
+void RelRoot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<RelRoot *>(to)->MergeFrom(
+      static_cast<const RelRoot &>(from));
+}
+
+
+void RelRoot::MergeFrom(const RelRoot& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelRoot)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  names_.MergeFrom(from.names_);
+  if (from._internal_has_input()) {
+    _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void RelRoot::CopyFrom(const RelRoot& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelRoot)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RelRoot::IsInitialized() const {
+  return true;
+}
+
+void RelRoot::InternalSwap(RelRoot* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  names_.InternalSwap(&other->names_);
+  swap(input_, other->input_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata RelRoot::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[24]);
+}
+
+// ===================================================================
+
+class Rel::_Internal {
+ public:
+  static const ::substrait::ReadRel& read(const Rel* msg);
+  static const ::substrait::FilterRel& filter(const Rel* msg);
+  static const ::substrait::FetchRel& fetch(const Rel* msg);
+  static const ::substrait::AggregateRel& aggregate(const Rel* msg);
+  static const ::substrait::SortRel& sort(const Rel* msg);
+  static const ::substrait::JoinRel& join(const Rel* msg);
+  static const ::substrait::ProjectRel& project(const Rel* msg);
+  static const ::substrait::SetRel& set(const Rel* msg);
+  static const ::substrait::ExtensionSingleRel& extension_single(const Rel* msg);
+  static const ::substrait::ExtensionMultiRel& extension_multi(const Rel* msg);
+  static const ::substrait::ExtensionLeafRel& extension_leaf(const Rel* msg);
+};
+
+const ::substrait::ReadRel&
+Rel::_Internal::read(const Rel* msg) {
+  return *msg->rel_type_.read_;
+}
+const ::substrait::FilterRel&
+Rel::_Internal::filter(const Rel* msg) {
+  return *msg->rel_type_.filter_;
+}
+const ::substrait::FetchRel&
+Rel::_Internal::fetch(const Rel* msg) {
+  return *msg->rel_type_.fetch_;
+}
+const ::substrait::AggregateRel&
+Rel::_Internal::aggregate(const Rel* msg) {
+  return *msg->rel_type_.aggregate_;
+}
+const ::substrait::SortRel&
+Rel::_Internal::sort(const Rel* msg) {
+  return *msg->rel_type_.sort_;
+}
+const ::substrait::JoinRel&
+Rel::_Internal::join(const Rel* msg) {
+  return *msg->rel_type_.join_;
+}
+const ::substrait::ProjectRel&
+Rel::_Internal::project(const Rel* msg) {
+  return *msg->rel_type_.project_;
+}
+const ::substrait::SetRel&
+Rel::_Internal::set(const Rel* msg) {
+  return *msg->rel_type_.set_;
+}
+const ::substrait::ExtensionSingleRel&
+Rel::_Internal::extension_single(const Rel* msg) {
+  return *msg->rel_type_.extension_single_;
+}
+const ::substrait::ExtensionMultiRel&
+Rel::_Internal::extension_multi(const Rel* msg) {
+  return *msg->rel_type_.extension_multi_;
+}
+const ::substrait::ExtensionLeafRel&
+Rel::_Internal::extension_leaf(const Rel* msg) {
+  return *msg->rel_type_.extension_leaf_;
+}
+void Rel::set_allocated_read(::substrait::ReadRel* read) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (read) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel>::GetOwningArena(read);
+    if (message_arena != submessage_arena) {
+      read = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, read, submessage_arena);
+    }
+    set_has_read();
+    rel_type_.read_ = read;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.read)
+}
+void Rel::set_allocated_filter(::substrait::FilterRel* filter) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (filter) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FilterRel>::GetOwningArena(filter);
+    if (message_arena != submessage_arena) {
+      filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, filter, submessage_arena);
+    }
+    set_has_filter();
+    rel_type_.filter_ = filter;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.filter)
+}
+void Rel::set_allocated_fetch(::substrait::FetchRel* fetch) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (fetch) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FetchRel>::GetOwningArena(fetch);
+    if (message_arena != submessage_arena) {
+      fetch = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fetch, submessage_arena);
+    }
+    set_has_fetch();
+    rel_type_.fetch_ = fetch;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.fetch)
+}
+void Rel::set_allocated_aggregate(::substrait::AggregateRel* aggregate) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (aggregate) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::AggregateRel>::GetOwningArena(aggregate);
+    if (message_arena != submessage_arena) {
+      aggregate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, aggregate, submessage_arena);
+    }
+    set_has_aggregate();
+    rel_type_.aggregate_ = aggregate;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.aggregate)
+}
+void Rel::set_allocated_sort(::substrait::SortRel* sort) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (sort) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::SortRel>::GetOwningArena(sort);
+    if (message_arena != submessage_arena) {
+      sort = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, sort, submessage_arena);
+    }
+    set_has_sort();
+    rel_type_.sort_ = sort;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.sort)
+}
+void Rel::set_allocated_join(::substrait::JoinRel* join) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (join) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::JoinRel>::GetOwningArena(join);
+    if (message_arena != submessage_arena) {
+      join = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, join, submessage_arena);
+    }
+    set_has_join();
+    rel_type_.join_ = join;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.join)
+}
+void Rel::set_allocated_project(::substrait::ProjectRel* project) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (project) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ProjectRel>::GetOwningArena(project);
+    if (message_arena != submessage_arena) {
+      project = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, project, submessage_arena);
+    }
+    set_has_project();
+    rel_type_.project_ = project;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.project)
+}
+void Rel::set_allocated_set(::substrait::SetRel* set) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (set) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::SetRel>::GetOwningArena(set);
+    if (message_arena != submessage_arena) {
+      set = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, set, submessage_arena);
+    }
+    set_has_set();
+    rel_type_.set_ = set;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.set)
+}
+void Rel::set_allocated_extension_single(::substrait::ExtensionSingleRel* extension_single) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (extension_single) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ExtensionSingleRel>::GetOwningArena(extension_single);
+    if (message_arena != submessage_arena) {
+      extension_single = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, extension_single, submessage_arena);
+    }
+    set_has_extension_single();
+    rel_type_.extension_single_ = extension_single;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_single)
+}
+void Rel::set_allocated_extension_multi(::substrait::ExtensionMultiRel* extension_multi) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (extension_multi) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ExtensionMultiRel>::GetOwningArena(extension_multi);
+    if (message_arena != submessage_arena) {
+      extension_multi = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, extension_multi, submessage_arena);
+    }
+    set_has_extension_multi();
+    rel_type_.extension_multi_ = extension_multi;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_multi)
+}
+void Rel::set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_leaf) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_rel_type();
+  if (extension_leaf) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ExtensionLeafRel>::GetOwningArena(extension_leaf);
+    if (message_arena != submessage_arena) {
+      extension_leaf = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, extension_leaf, submessage_arena);
+    }
+    set_has_extension_leaf();
+    rel_type_.extension_leaf_ = extension_leaf;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_leaf)
+}
+Rel::Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Rel)
+}
+Rel::Rel(const Rel& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_rel_type();
+  switch (from.rel_type_case()) {
+    case kRead: {
+      _internal_mutable_read()->::substrait::ReadRel::MergeFrom(from._internal_read());
+      break;
+    }
+    case kFilter: {
+      _internal_mutable_filter()->::substrait::FilterRel::MergeFrom(from._internal_filter());
+      break;
+    }
+    case kFetch: {
+      _internal_mutable_fetch()->::substrait::FetchRel::MergeFrom(from._internal_fetch());
+      break;
+    }
+    case kAggregate: {
+      _internal_mutable_aggregate()->::substrait::AggregateRel::MergeFrom(from._internal_aggregate());
+      break;
+    }
+    case kSort: {
+      _internal_mutable_sort()->::substrait::SortRel::MergeFrom(from._internal_sort());
+      break;
+    }
+    case kJoin: {
+      _internal_mutable_join()->::substrait::JoinRel::MergeFrom(from._internal_join());
+      break;
+    }
+    case kProject: {
+      _internal_mutable_project()->::substrait::ProjectRel::MergeFrom(from._internal_project());
+      break;
+    }
+    case kSet: {
+      _internal_mutable_set()->::substrait::SetRel::MergeFrom(from._internal_set());
+      break;
+    }
+    case kExtensionSingle: {
+      _internal_mutable_extension_single()->::substrait::ExtensionSingleRel::MergeFrom(from._internal_extension_single());
+      break;
+    }
+    case kExtensionMulti: {
+      _internal_mutable_extension_multi()->::substrait::ExtensionMultiRel::MergeFrom(from._internal_extension_multi());
+      break;
+    }
+    case kExtensionLeaf: {
+      _internal_mutable_extension_leaf()->::substrait::ExtensionLeafRel::MergeFrom(from._internal_extension_leaf());
+      break;
+    }
+    case REL_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Rel)
+}
+
+inline void Rel::SharedCtor() {
+clear_has_rel_type();
+}
+
+Rel::~Rel() {
+  // @@protoc_insertion_point(destructor:substrait.Rel)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Rel::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_rel_type()) {
+    clear_rel_type();
+  }
+}
+
+void Rel::ArenaDtor(void* object) {
+  Rel* _this = reinterpret_cast< Rel* >(object);
+  (void)_this;
+}
+void Rel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Rel::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Rel::clear_rel_type() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Rel)
+  switch (rel_type_case()) {
+    case kRead: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.read_;
+      }
+      break;
+    }
+    case kFilter: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.filter_;
+      }
+      break;
+    }
+    case kFetch: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.fetch_;
+      }
+      break;
+    }
+    case kAggregate: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.aggregate_;
+      }
+      break;
+    }
+    case kSort: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.sort_;
+      }
+      break;
+    }
+    case kJoin: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.join_;
+      }
+      break;
+    }
+    case kProject: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.project_;
+      }
+      break;
+    }
+    case kSet: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.set_;
+      }
+      break;
+    }
+    case kExtensionSingle: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.extension_single_;
+      }
+      break;
+    }
+    case kExtensionMulti: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.extension_multi_;
+      }
+      break;
+    }
+    case kExtensionLeaf: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete rel_type_.extension_leaf_;
+      }
+      break;
+    }
+    case REL_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = REL_TYPE_NOT_SET;
+}
+
+
+void Rel::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Rel)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_rel_type();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Rel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.ReadRel read = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_read(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FilterRel filter = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.FetchRel fetch = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fetch(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.AggregateRel aggregate = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_aggregate(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.SortRel sort = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_sort(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.JoinRel join = 6;
+      case 6:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_join(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ProjectRel project = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_project(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.SetRel set = 8;
+      case 8:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+          ptr = ctx->ParseMessage(_internal_mutable_set(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ExtensionSingleRel extension_single = 9;
+      case 9:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+          ptr = ctx->ParseMessage(_internal_mutable_extension_single(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ExtensionMultiRel extension_multi = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_extension_multi(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.ExtensionLeafRel extension_leaf = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr = ctx->ParseMessage(_internal_mutable_extension_leaf(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Rel::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Rel)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.ReadRel read = 1;
+  if (_internal_has_read()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::read(this), target, stream);
+  }
+
+  // .substrait.FilterRel filter = 2;
+  if (_internal_has_filter()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::filter(this), target, stream);
+  }
+
+  // .substrait.FetchRel fetch = 3;
+  if (_internal_has_fetch()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::fetch(this), target, stream);
+  }
+
+  // .substrait.AggregateRel aggregate = 4;
+  if (_internal_has_aggregate()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::aggregate(this), target, stream);
+  }
+
+  // .substrait.SortRel sort = 5;
+  if (_internal_has_sort()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        5, _Internal::sort(this), target, stream);
+  }
+
+  // .substrait.JoinRel join = 6;
+  if (_internal_has_join()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        6, _Internal::join(this), target, stream);
+  }
+
+  // .substrait.ProjectRel project = 7;
+  if (_internal_has_project()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        7, _Internal::project(this), target, stream);
+  }
+
+  // .substrait.SetRel set = 8;
+  if (_internal_has_set()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        8, _Internal::set(this), target, stream);
+  }
+
+  // .substrait.ExtensionSingleRel extension_single = 9;
+  if (_internal_has_extension_single()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        9, _Internal::extension_single(this), target, stream);
+  }
+
+  // .substrait.ExtensionMultiRel extension_multi = 10;
+  if (_internal_has_extension_multi()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::extension_multi(this), target, stream);
+  }
+
+  // .substrait.ExtensionLeafRel extension_leaf = 11;
+  if (_internal_has_extension_leaf()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        11, _Internal::extension_leaf(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Rel)
+  return target;
+}
+
+size_t Rel::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Rel)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (rel_type_case()) {
+    // .substrait.ReadRel read = 1;
+    case kRead: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.read_);
+      break;
+    }
+    // .substrait.FilterRel filter = 2;
+    case kFilter: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.filter_);
+      break;
+    }
+    // .substrait.FetchRel fetch = 3;
+    case kFetch: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.fetch_);
+      break;
+    }
+    // .substrait.AggregateRel aggregate = 4;
+    case kAggregate: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.aggregate_);
+      break;
+    }
+    // .substrait.SortRel sort = 5;
+    case kSort: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.sort_);
+      break;
+    }
+    // .substrait.JoinRel join = 6;
+    case kJoin: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.join_);
+      break;
+    }
+    // .substrait.ProjectRel project = 7;
+    case kProject: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.project_);
+      break;
+    }
+    // .substrait.SetRel set = 8;
+    case kSet: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.set_);
+      break;
+    }
+    // .substrait.ExtensionSingleRel extension_single = 9;
+    case kExtensionSingle: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.extension_single_);
+      break;
+    }
+    // .substrait.ExtensionMultiRel extension_multi = 10;
+    case kExtensionMulti: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.extension_multi_);
+      break;
+    }
+    // .substrait.ExtensionLeafRel extension_leaf = 11;
+    case kExtensionLeaf: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *rel_type_.extension_leaf_);
+      break;
+    }
+    case REL_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Rel::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Rel::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Rel::GetClassData() const { return &_class_data_; }
+
+void Rel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Rel *>(to)->MergeFrom(
+      static_cast<const Rel &>(from));
+}
+
+
+void Rel::MergeFrom(const Rel& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Rel)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.rel_type_case()) {
+    case kRead: {
+      _internal_mutable_read()->::substrait::ReadRel::MergeFrom(from._internal_read());
+      break;
+    }
+    case kFilter: {
+      _internal_mutable_filter()->::substrait::FilterRel::MergeFrom(from._internal_filter());
+      break;
+    }
+    case kFetch: {
+      _internal_mutable_fetch()->::substrait::FetchRel::MergeFrom(from._internal_fetch());
+      break;
+    }
+    case kAggregate: {
+      _internal_mutable_aggregate()->::substrait::AggregateRel::MergeFrom(from._internal_aggregate());
+      break;
+    }
+    case kSort: {
+      _internal_mutable_sort()->::substrait::SortRel::MergeFrom(from._internal_sort());
+      break;
+    }
+    case kJoin: {
+      _internal_mutable_join()->::substrait::JoinRel::MergeFrom(from._internal_join());
+      break;
+    }
+    case kProject: {
+      _internal_mutable_project()->::substrait::ProjectRel::MergeFrom(from._internal_project());
+      break;
+    }
+    case kSet: {
+      _internal_mutable_set()->::substrait::SetRel::MergeFrom(from._internal_set());
+      break;
+    }
+    case kExtensionSingle: {
+      _internal_mutable_extension_single()->::substrait::ExtensionSingleRel::MergeFrom(from._internal_extension_single());
+      break;
+    }
+    case kExtensionMulti: {
+      _internal_mutable_extension_multi()->::substrait::ExtensionMultiRel::MergeFrom(from._internal_extension_multi());
+      break;
+    }
+    case kExtensionLeaf: {
+      _internal_mutable_extension_leaf()->::substrait::ExtensionLeafRel::MergeFrom(from._internal_extension_leaf());
+      break;
+    }
+    case REL_TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Rel::CopyFrom(const Rel& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Rel)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Rel::IsInitialized() const {
+  return true;
+}
+
+void Rel::InternalSwap(Rel* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(rel_type_, other->rel_type_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Rel::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once,
+      file_level_metadata_substrait_2frelations_2eproto[25]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Direct* Arena::CreateMaybeMessage< ::substrait::RelCommon_Direct >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::RelCommon_Direct >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Emit* Arena::CreateMaybeMessage< ::substrait::RelCommon_Emit >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::RelCommon_Emit >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage< ::substrait::RelCommon_Hint_Stats >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::RelCommon_Hint_Stats >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Hint_RuntimeConstraint* Arena::CreateMaybeMessage< ::substrait::RelCommon_Hint_RuntimeConstraint >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::RelCommon_Hint_RuntimeConstraint >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Hint* Arena::CreateMaybeMessage< ::substrait::RelCommon_Hint >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::RelCommon_Hint >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::RelCommon* Arena::CreateMaybeMessage< ::substrait::RelCommon >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::RelCommon >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ReadRel_NamedTable* Arena::CreateMaybeMessage< ::substrait::ReadRel_NamedTable >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ReadRel_NamedTable >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ReadRel_VirtualTable* Arena::CreateMaybeMessage< ::substrait::ReadRel_VirtualTable >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ReadRel_VirtualTable >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ReadRel_ExtensionTable* Arena::CreateMaybeMessage< ::substrait::ReadRel_ExtensionTable >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ReadRel_ExtensionTable >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage< ::substrait::ReadRel_LocalFiles_FileOrFiles >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ReadRel_LocalFiles_FileOrFiles >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ReadRel_LocalFiles* Arena::CreateMaybeMessage< ::substrait::ReadRel_LocalFiles >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ReadRel_LocalFiles >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ReadRel* Arena::CreateMaybeMessage< ::substrait::ReadRel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ReadRel >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ProjectRel* Arena::CreateMaybeMessage< ::substrait::ProjectRel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ProjectRel >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::JoinRel* Arena::CreateMaybeMessage< ::substrait::JoinRel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::JoinRel >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FetchRel* Arena::CreateMaybeMessage< ::substrait::FetchRel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FetchRel >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::AggregateRel_Grouping* Arena::CreateMaybeMessage< ::substrait::AggregateRel_Grouping >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::AggregateRel_Grouping >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::AggregateRel_Measure* Arena::CreateMaybeMessage< ::substrait::AggregateRel_Measure >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::AggregateRel_Measure >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::AggregateRel* Arena::CreateMaybeMessage< ::substrait::AggregateRel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::AggregateRel >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::SortRel* Arena::CreateMaybeMessage< ::substrait::SortRel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::SortRel >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::FilterRel* Arena::CreateMaybeMessage< ::substrait::FilterRel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::FilterRel >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::SetRel* Arena::CreateMaybeMessage< ::substrait::SetRel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::SetRel >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ExtensionSingleRel* Arena::CreateMaybeMessage< ::substrait::ExtensionSingleRel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ExtensionSingleRel >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ExtensionLeafRel* Arena::CreateMaybeMessage< ::substrait::ExtensionLeafRel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ExtensionLeafRel >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::ExtensionMultiRel* Arena::CreateMaybeMessage< ::substrait::ExtensionMultiRel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::ExtensionMultiRel >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::RelRoot* Arena::CreateMaybeMessage< ::substrait::RelRoot >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::RelRoot >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Rel* Arena::CreateMaybeMessage< ::substrait::Rel >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Rel >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/cpp/src/generated/substrait/relations.pb.h b/cpp/src/generated/substrait/relations.pb.h
new file mode 100644
index 000000000000..11f499cb1ab0
--- /dev/null
+++ b/cpp/src/generated/substrait/relations.pb.h
@@ -0,0 +1,12611 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/relations.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2frelations_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_substrait_2frelations_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3019000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3019003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_bases.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "substrait/type.pb.h"
+#include "substrait/expression.pb.h"
+#include "substrait/extensions/extensions.pb.h"
+#include <google/protobuf/any.pb.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_substrait_2frelations_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_substrait_2frelations_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[26]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2frelations_2eproto;
+namespace substrait {
+class AggregateRel;
+struct AggregateRelDefaultTypeInternal;
+extern AggregateRelDefaultTypeInternal _AggregateRel_default_instance_;
+class AggregateRel_Grouping;
+struct AggregateRel_GroupingDefaultTypeInternal;
+extern AggregateRel_GroupingDefaultTypeInternal _AggregateRel_Grouping_default_instance_;
+class AggregateRel_Measure;
+struct AggregateRel_MeasureDefaultTypeInternal;
+extern AggregateRel_MeasureDefaultTypeInternal _AggregateRel_Measure_default_instance_;
+class ExtensionLeafRel;
+struct ExtensionLeafRelDefaultTypeInternal;
+extern ExtensionLeafRelDefaultTypeInternal _ExtensionLeafRel_default_instance_;
+class ExtensionMultiRel;
+struct ExtensionMultiRelDefaultTypeInternal;
+extern ExtensionMultiRelDefaultTypeInternal _ExtensionMultiRel_default_instance_;
+class ExtensionSingleRel;
+struct ExtensionSingleRelDefaultTypeInternal;
+extern ExtensionSingleRelDefaultTypeInternal _ExtensionSingleRel_default_instance_;
+class FetchRel;
+struct FetchRelDefaultTypeInternal;
+extern FetchRelDefaultTypeInternal _FetchRel_default_instance_;
+class FilterRel;
+struct FilterRelDefaultTypeInternal;
+extern FilterRelDefaultTypeInternal _FilterRel_default_instance_;
+class JoinRel;
+struct JoinRelDefaultTypeInternal;
+extern JoinRelDefaultTypeInternal _JoinRel_default_instance_;
+class ProjectRel;
+struct ProjectRelDefaultTypeInternal;
+extern ProjectRelDefaultTypeInternal _ProjectRel_default_instance_;
+class ReadRel;
+struct ReadRelDefaultTypeInternal;
+extern ReadRelDefaultTypeInternal _ReadRel_default_instance_;
+class ReadRel_ExtensionTable;
+struct ReadRel_ExtensionTableDefaultTypeInternal;
+extern ReadRel_ExtensionTableDefaultTypeInternal _ReadRel_ExtensionTable_default_instance_;
+class ReadRel_LocalFiles;
+struct ReadRel_LocalFilesDefaultTypeInternal;
+extern ReadRel_LocalFilesDefaultTypeInternal _ReadRel_LocalFiles_default_instance_;
+class ReadRel_LocalFiles_FileOrFiles;
+struct ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal;
+extern ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal _ReadRel_LocalFiles_FileOrFiles_default_instance_;
+class ReadRel_NamedTable;
+struct ReadRel_NamedTableDefaultTypeInternal;
+extern ReadRel_NamedTableDefaultTypeInternal _ReadRel_NamedTable_default_instance_;
+class ReadRel_VirtualTable;
+struct ReadRel_VirtualTableDefaultTypeInternal;
+extern ReadRel_VirtualTableDefaultTypeInternal _ReadRel_VirtualTable_default_instance_;
+class Rel;
+struct RelDefaultTypeInternal;
+extern RelDefaultTypeInternal _Rel_default_instance_;
+class RelCommon;
+struct RelCommonDefaultTypeInternal;
+extern RelCommonDefaultTypeInternal _RelCommon_default_instance_;
+class RelCommon_Direct;
+struct RelCommon_DirectDefaultTypeInternal;
+extern RelCommon_DirectDefaultTypeInternal _RelCommon_Direct_default_instance_;
+class RelCommon_Emit;
+struct RelCommon_EmitDefaultTypeInternal;
+extern RelCommon_EmitDefaultTypeInternal _RelCommon_Emit_default_instance_;
+class RelCommon_Hint;
+struct RelCommon_HintDefaultTypeInternal;
+extern RelCommon_HintDefaultTypeInternal _RelCommon_Hint_default_instance_;
+class RelCommon_Hint_RuntimeConstraint;
+struct RelCommon_Hint_RuntimeConstraintDefaultTypeInternal;
+extern RelCommon_Hint_RuntimeConstraintDefaultTypeInternal _RelCommon_Hint_RuntimeConstraint_default_instance_;
+class RelCommon_Hint_Stats;
+struct RelCommon_Hint_StatsDefaultTypeInternal;
+extern RelCommon_Hint_StatsDefaultTypeInternal _RelCommon_Hint_Stats_default_instance_;
+class RelRoot;
+struct RelRootDefaultTypeInternal;
+extern RelRootDefaultTypeInternal _RelRoot_default_instance_;
+class SetRel;
+struct SetRelDefaultTypeInternal;
+extern SetRelDefaultTypeInternal _SetRel_default_instance_;
+class SortRel;
+struct SortRelDefaultTypeInternal;
+extern SortRelDefaultTypeInternal _SortRel_default_instance_;
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> ::substrait::AggregateRel* Arena::CreateMaybeMessage<::substrait::AggregateRel>(Arena*);
+template<> ::substrait::AggregateRel_Grouping* Arena::CreateMaybeMessage<::substrait::AggregateRel_Grouping>(Arena*);
+template<> ::substrait::AggregateRel_Measure* Arena::CreateMaybeMessage<::substrait::AggregateRel_Measure>(Arena*);
+template<> ::substrait::ExtensionLeafRel* Arena::CreateMaybeMessage<::substrait::ExtensionLeafRel>(Arena*);
+template<> ::substrait::ExtensionMultiRel* Arena::CreateMaybeMessage<::substrait::ExtensionMultiRel>(Arena*);
+template<> ::substrait::ExtensionSingleRel* Arena::CreateMaybeMessage<::substrait::ExtensionSingleRel>(Arena*);
+template<> ::substrait::FetchRel* Arena::CreateMaybeMessage<::substrait::FetchRel>(Arena*);
+template<> ::substrait::FilterRel* Arena::CreateMaybeMessage<::substrait::FilterRel>(Arena*);
+template<> ::substrait::JoinRel* Arena::CreateMaybeMessage<::substrait::JoinRel>(Arena*);
+template<> ::substrait::ProjectRel* Arena::CreateMaybeMessage<::substrait::ProjectRel>(Arena*);
+template<> ::substrait::ReadRel* Arena::CreateMaybeMessage<::substrait::ReadRel>(Arena*);
+template<> ::substrait::ReadRel_ExtensionTable* Arena::CreateMaybeMessage<::substrait::ReadRel_ExtensionTable>(Arena*);
+template<> ::substrait::ReadRel_LocalFiles* Arena::CreateMaybeMessage<::substrait::ReadRel_LocalFiles>(Arena*);
+template<> ::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage<::substrait::ReadRel_LocalFiles_FileOrFiles>(Arena*);
+template<> ::substrait::ReadRel_NamedTable* Arena::CreateMaybeMessage<::substrait::ReadRel_NamedTable>(Arena*);
+template<> ::substrait::ReadRel_VirtualTable* Arena::CreateMaybeMessage<::substrait::ReadRel_VirtualTable>(Arena*);
+template<> ::substrait::Rel* Arena::CreateMaybeMessage<::substrait::Rel>(Arena*);
+template<> ::substrait::RelCommon* Arena::CreateMaybeMessage<::substrait::RelCommon>(Arena*);
+template<> ::substrait::RelCommon_Direct* Arena::CreateMaybeMessage<::substrait::RelCommon_Direct>(Arena*);
+template<> ::substrait::RelCommon_Emit* Arena::CreateMaybeMessage<::substrait::RelCommon_Emit>(Arena*);
+template<> ::substrait::RelCommon_Hint* Arena::CreateMaybeMessage<::substrait::RelCommon_Hint>(Arena*);
+template<> ::substrait::RelCommon_Hint_RuntimeConstraint* Arena::CreateMaybeMessage<::substrait::RelCommon_Hint_RuntimeConstraint>(Arena*);
+template<> ::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage<::substrait::RelCommon_Hint_Stats>(Arena*);
+template<> ::substrait::RelRoot* Arena::CreateMaybeMessage<::substrait::RelRoot>(Arena*);
+template<> ::substrait::SetRel* Arena::CreateMaybeMessage<::substrait::SetRel>(Arena*);
+template<> ::substrait::SortRel* Arena::CreateMaybeMessage<::substrait::SortRel>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace substrait {
+
+enum ReadRel_LocalFiles_FileOrFiles_FileFormat : int {
+  ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_UNSPECIFIED = 0,
+  ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_PARQUET = 1,
+  ReadRel_LocalFiles_FileOrFiles_FileFormat_ReadRel_LocalFiles_FileOrFiles_FileFormat_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  ReadRel_LocalFiles_FileOrFiles_FileFormat_ReadRel_LocalFiles_FileOrFiles_FileFormat_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool ReadRel_LocalFiles_FileOrFiles_FileFormat_IsValid(int value);
+constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MIN = ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_UNSPECIFIED;
+constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MAX = ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_PARQUET;
+constexpr int ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_ARRAYSIZE = ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor();
+template<typename T>
+inline const std::string& ReadRel_LocalFiles_FileOrFiles_FileFormat_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ReadRel_LocalFiles_FileOrFiles_FileFormat>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ReadRel_LocalFiles_FileOrFiles_FileFormat_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor(), enum_t_value);
+}
+inline bool ReadRel_LocalFiles_FileOrFiles_FileFormat_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReadRel_LocalFiles_FileOrFiles_FileFormat* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ReadRel_LocalFiles_FileOrFiles_FileFormat>(
+    ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor(), name, value);
+}
+enum JoinRel_JoinType : int {
+  JoinRel_JoinType_JOIN_TYPE_UNSPECIFIED = 0,
+  JoinRel_JoinType_JOIN_TYPE_INNER = 1,
+  JoinRel_JoinType_JOIN_TYPE_OUTER = 2,
+  JoinRel_JoinType_JOIN_TYPE_LEFT = 3,
+  JoinRel_JoinType_JOIN_TYPE_RIGHT = 4,
+  JoinRel_JoinType_JOIN_TYPE_SEMI = 5,
+  JoinRel_JoinType_JOIN_TYPE_ANTI = 6,
+  JoinRel_JoinType_JoinRel_JoinType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  JoinRel_JoinType_JoinRel_JoinType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool JoinRel_JoinType_IsValid(int value);
+constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MIN = JoinRel_JoinType_JOIN_TYPE_UNSPECIFIED;
+constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MAX = JoinRel_JoinType_JOIN_TYPE_ANTI;
+constexpr int JoinRel_JoinType_JoinType_ARRAYSIZE = JoinRel_JoinType_JoinType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinRel_JoinType_descriptor();
+template<typename T>
+inline const std::string& JoinRel_JoinType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, JoinRel_JoinType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function JoinRel_JoinType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    JoinRel_JoinType_descriptor(), enum_t_value);
+}
+inline bool JoinRel_JoinType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, JoinRel_JoinType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<JoinRel_JoinType>(
+    JoinRel_JoinType_descriptor(), name, value);
+}
+enum SetRel_SetOp : int {
+  SetRel_SetOp_SET_OP_UNSPECIFIED = 0,
+  SetRel_SetOp_SET_OP_MINUS_PRIMARY = 1,
+  SetRel_SetOp_SET_OP_MINUS_MULTISET = 2,
+  SetRel_SetOp_SET_OP_INTERSECTION_PRIMARY = 3,
+  SetRel_SetOp_SET_OP_INTERSECTION_MULTISET = 4,
+  SetRel_SetOp_SET_OP_UNION_DISTINCT = 5,
+  SetRel_SetOp_SET_OP_UNION_ALL = 6,
+  SetRel_SetOp_SetRel_SetOp_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  SetRel_SetOp_SetRel_SetOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool SetRel_SetOp_IsValid(int value);
+constexpr SetRel_SetOp SetRel_SetOp_SetOp_MIN = SetRel_SetOp_SET_OP_UNSPECIFIED;
+constexpr SetRel_SetOp SetRel_SetOp_SetOp_MAX = SetRel_SetOp_SET_OP_UNION_ALL;
+constexpr int SetRel_SetOp_SetOp_ARRAYSIZE = SetRel_SetOp_SetOp_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetRel_SetOp_descriptor();
+template<typename T>
+inline const std::string& SetRel_SetOp_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SetRel_SetOp>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SetRel_SetOp_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SetRel_SetOp_descriptor(), enum_t_value);
+}
+inline bool SetRel_SetOp_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SetRel_SetOp* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SetRel_SetOp>(
+    SetRel_SetOp_descriptor(), name, value);
+}
+// ===================================================================
+
+class RelCommon_Direct final :
+    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Direct) */ {
+ public:
+  inline RelCommon_Direct() : RelCommon_Direct(nullptr) {}
+  explicit constexpr RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RelCommon_Direct(const RelCommon_Direct& from);
+  RelCommon_Direct(RelCommon_Direct&& from) noexcept
+    : RelCommon_Direct() {
+    *this = ::std::move(from);
+  }
+
+  inline RelCommon_Direct& operator=(const RelCommon_Direct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RelCommon_Direct& operator=(RelCommon_Direct&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RelCommon_Direct& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RelCommon_Direct* internal_default_instance() {
+    return reinterpret_cast<const RelCommon_Direct*>(
+               &_RelCommon_Direct_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(RelCommon_Direct& a, RelCommon_Direct& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RelCommon_Direct* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RelCommon_Direct* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RelCommon_Direct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RelCommon_Direct>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
+  inline void CopyFrom(const RelCommon_Direct& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
+  void MergeFrom(const RelCommon_Direct& from) {
+    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from);
+  }
+  public:
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.RelCommon.Direct";
+  }
+  protected:
+  explicit RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:substrait.RelCommon.Direct)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RelCommon_Emit final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Emit) */ {
+ public:
+  inline RelCommon_Emit() : RelCommon_Emit(nullptr) {}
+  ~RelCommon_Emit() override;
+  explicit constexpr RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RelCommon_Emit(const RelCommon_Emit& from);
+  RelCommon_Emit(RelCommon_Emit&& from) noexcept
+    : RelCommon_Emit() {
+    *this = ::std::move(from);
+  }
+
+  inline RelCommon_Emit& operator=(const RelCommon_Emit& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RelCommon_Emit& operator=(RelCommon_Emit&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RelCommon_Emit& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RelCommon_Emit* internal_default_instance() {
+    return reinterpret_cast<const RelCommon_Emit*>(
+               &_RelCommon_Emit_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(RelCommon_Emit& a, RelCommon_Emit& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RelCommon_Emit* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RelCommon_Emit* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RelCommon_Emit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RelCommon_Emit>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RelCommon_Emit& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const RelCommon_Emit& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RelCommon_Emit* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.RelCommon.Emit";
+  }
+  protected:
+  explicit RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOutputMappingFieldNumber = 1,
+  };
+  // repeated int32 output_mapping = 1;
+  int output_mapping_size() const;
+  private:
+  int _internal_output_mapping_size() const;
+  public:
+  void clear_output_mapping();
+  private:
+  int32_t _internal_output_mapping(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_output_mapping() const;
+  void _internal_add_output_mapping(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_output_mapping();
+  public:
+  int32_t output_mapping(int index) const;
+  void set_output_mapping(int index, int32_t value);
+  void add_output_mapping(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      output_mapping() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_output_mapping();
+
+  // @@protoc_insertion_point(class_scope:substrait.RelCommon.Emit)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > output_mapping_;
+  mutable std::atomic<int> _output_mapping_cached_byte_size_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RelCommon_Hint_Stats final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Hint.Stats) */ {
+ public:
+  inline RelCommon_Hint_Stats() : RelCommon_Hint_Stats(nullptr) {}
+  ~RelCommon_Hint_Stats() override;
+  explicit constexpr RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RelCommon_Hint_Stats(const RelCommon_Hint_Stats& from);
+  RelCommon_Hint_Stats(RelCommon_Hint_Stats&& from) noexcept
+    : RelCommon_Hint_Stats() {
+    *this = ::std::move(from);
+  }
+
+  inline RelCommon_Hint_Stats& operator=(const RelCommon_Hint_Stats& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RelCommon_Hint_Stats& operator=(RelCommon_Hint_Stats&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RelCommon_Hint_Stats& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RelCommon_Hint_Stats* internal_default_instance() {
+    return reinterpret_cast<const RelCommon_Hint_Stats*>(
+               &_RelCommon_Hint_Stats_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(RelCommon_Hint_Stats& a, RelCommon_Hint_Stats& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RelCommon_Hint_Stats* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RelCommon_Hint_Stats* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RelCommon_Hint_Stats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RelCommon_Hint_Stats>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RelCommon_Hint_Stats& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const RelCommon_Hint_Stats& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RelCommon_Hint_Stats* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.RelCommon.Hint.Stats";
+  }
+  protected:
+  explicit RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAdvancedExtensionFieldNumber = 10,
+    kRowCountFieldNumber = 1,
+    kRecordSizeFieldNumber = 2,
+  };
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // double row_count = 1;
+  void clear_row_count();
+  double row_count() const;
+  void set_row_count(double value);
+  private:
+  double _internal_row_count() const;
+  void _internal_set_row_count(double value);
+  public:
+
+  // double record_size = 2;
+  void clear_record_size();
+  double record_size() const;
+  void set_record_size(double value);
+  private:
+  double _internal_record_size() const;
+  void _internal_set_record_size(double value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.RelCommon.Hint.Stats)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  double row_count_;
+  double record_size_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RelCommon_Hint_RuntimeConstraint final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Hint.RuntimeConstraint) */ {
+ public:
+  inline RelCommon_Hint_RuntimeConstraint() : RelCommon_Hint_RuntimeConstraint(nullptr) {}
+  ~RelCommon_Hint_RuntimeConstraint() override;
+  explicit constexpr RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RelCommon_Hint_RuntimeConstraint(const RelCommon_Hint_RuntimeConstraint& from);
+  RelCommon_Hint_RuntimeConstraint(RelCommon_Hint_RuntimeConstraint&& from) noexcept
+    : RelCommon_Hint_RuntimeConstraint() {
+    *this = ::std::move(from);
+  }
+
+  inline RelCommon_Hint_RuntimeConstraint& operator=(const RelCommon_Hint_RuntimeConstraint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RelCommon_Hint_RuntimeConstraint& operator=(RelCommon_Hint_RuntimeConstraint&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RelCommon_Hint_RuntimeConstraint& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RelCommon_Hint_RuntimeConstraint* internal_default_instance() {
+    return reinterpret_cast<const RelCommon_Hint_RuntimeConstraint*>(
+               &_RelCommon_Hint_RuntimeConstraint_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(RelCommon_Hint_RuntimeConstraint& a, RelCommon_Hint_RuntimeConstraint& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RelCommon_Hint_RuntimeConstraint* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RelCommon_Hint_RuntimeConstraint* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RelCommon_Hint_RuntimeConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RelCommon_Hint_RuntimeConstraint>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RelCommon_Hint_RuntimeConstraint& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const RelCommon_Hint_RuntimeConstraint& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RelCommon_Hint_RuntimeConstraint* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.RelCommon.Hint.RuntimeConstraint";
+  }
+  protected:
+  explicit RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAdvancedExtensionFieldNumber = 10,
+  };
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // @@protoc_insertion_point(class_scope:substrait.RelCommon.Hint.RuntimeConstraint)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RelCommon_Hint final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Hint) */ {
+ public:
+  inline RelCommon_Hint() : RelCommon_Hint(nullptr) {}
+  ~RelCommon_Hint() override;
+  explicit constexpr RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RelCommon_Hint(const RelCommon_Hint& from);
+  RelCommon_Hint(RelCommon_Hint&& from) noexcept
+    : RelCommon_Hint() {
+    *this = ::std::move(from);
+  }
+
+  inline RelCommon_Hint& operator=(const RelCommon_Hint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RelCommon_Hint& operator=(RelCommon_Hint&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RelCommon_Hint& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RelCommon_Hint* internal_default_instance() {
+    return reinterpret_cast<const RelCommon_Hint*>(
+               &_RelCommon_Hint_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(RelCommon_Hint& a, RelCommon_Hint& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RelCommon_Hint* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RelCommon_Hint* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RelCommon_Hint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RelCommon_Hint>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RelCommon_Hint& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const RelCommon_Hint& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RelCommon_Hint* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.RelCommon.Hint";
+  }
+  protected:
+  explicit RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef RelCommon_Hint_Stats Stats;
+  typedef RelCommon_Hint_RuntimeConstraint RuntimeConstraint;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStatsFieldNumber = 1,
+    kConstraintFieldNumber = 2,
+    kAdvancedExtensionFieldNumber = 10,
+  };
+  // .substrait.RelCommon.Hint.Stats stats = 1;
+  bool has_stats() const;
+  private:
+  bool _internal_has_stats() const;
+  public:
+  void clear_stats();
+  const ::substrait::RelCommon_Hint_Stats& stats() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon_Hint_Stats* release_stats();
+  ::substrait::RelCommon_Hint_Stats* mutable_stats();
+  void set_allocated_stats(::substrait::RelCommon_Hint_Stats* stats);
+  private:
+  const ::substrait::RelCommon_Hint_Stats& _internal_stats() const;
+  ::substrait::RelCommon_Hint_Stats* _internal_mutable_stats();
+  public:
+  void unsafe_arena_set_allocated_stats(
+      ::substrait::RelCommon_Hint_Stats* stats);
+  ::substrait::RelCommon_Hint_Stats* unsafe_arena_release_stats();
+
+  // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2;
+  bool has_constraint() const;
+  private:
+  bool _internal_has_constraint() const;
+  public:
+  void clear_constraint();
+  const ::substrait::RelCommon_Hint_RuntimeConstraint& constraint() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon_Hint_RuntimeConstraint* release_constraint();
+  ::substrait::RelCommon_Hint_RuntimeConstraint* mutable_constraint();
+  void set_allocated_constraint(::substrait::RelCommon_Hint_RuntimeConstraint* constraint);
+  private:
+  const ::substrait::RelCommon_Hint_RuntimeConstraint& _internal_constraint() const;
+  ::substrait::RelCommon_Hint_RuntimeConstraint* _internal_mutable_constraint();
+  public:
+  void unsafe_arena_set_allocated_constraint(
+      ::substrait::RelCommon_Hint_RuntimeConstraint* constraint);
+  ::substrait::RelCommon_Hint_RuntimeConstraint* unsafe_arena_release_constraint();
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // @@protoc_insertion_point(class_scope:substrait.RelCommon.Hint)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::RelCommon_Hint_Stats* stats_;
+  ::substrait::RelCommon_Hint_RuntimeConstraint* constraint_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RelCommon final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon) */ {
+ public:
+  inline RelCommon() : RelCommon(nullptr) {}
+  ~RelCommon() override;
+  explicit constexpr RelCommon(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RelCommon(const RelCommon& from);
+  RelCommon(RelCommon&& from) noexcept
+    : RelCommon() {
+    *this = ::std::move(from);
+  }
+
+  inline RelCommon& operator=(const RelCommon& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RelCommon& operator=(RelCommon&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RelCommon& default_instance() {
+    return *internal_default_instance();
+  }
+  enum EmitKindCase {
+    kDirect = 1,
+    kEmit = 2,
+    EMIT_KIND_NOT_SET = 0,
+  };
+
+  static inline const RelCommon* internal_default_instance() {
+    return reinterpret_cast<const RelCommon*>(
+               &_RelCommon_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(RelCommon& a, RelCommon& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RelCommon* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RelCommon* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RelCommon* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RelCommon>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RelCommon& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const RelCommon& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RelCommon* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.RelCommon";
+  }
+  protected:
+  explicit RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef RelCommon_Direct Direct;
+  typedef RelCommon_Emit Emit;
+  typedef RelCommon_Hint Hint;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHintFieldNumber = 3,
+    kAdvancedExtensionFieldNumber = 4,
+    kDirectFieldNumber = 1,
+    kEmitFieldNumber = 2,
+  };
+  // .substrait.RelCommon.Hint hint = 3;
+  bool has_hint() const;
+  private:
+  bool _internal_has_hint() const;
+  public:
+  void clear_hint();
+  const ::substrait::RelCommon_Hint& hint() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon_Hint* release_hint();
+  ::substrait::RelCommon_Hint* mutable_hint();
+  void set_allocated_hint(::substrait::RelCommon_Hint* hint);
+  private:
+  const ::substrait::RelCommon_Hint& _internal_hint() const;
+  ::substrait::RelCommon_Hint* _internal_mutable_hint();
+  public:
+  void unsafe_arena_set_allocated_hint(
+      ::substrait::RelCommon_Hint* hint);
+  ::substrait::RelCommon_Hint* unsafe_arena_release_hint();
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 4;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // .substrait.RelCommon.Direct direct = 1;
+  bool has_direct() const;
+  private:
+  bool _internal_has_direct() const;
+  public:
+  void clear_direct();
+  const ::substrait::RelCommon_Direct& direct() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon_Direct* release_direct();
+  ::substrait::RelCommon_Direct* mutable_direct();
+  void set_allocated_direct(::substrait::RelCommon_Direct* direct);
+  private:
+  const ::substrait::RelCommon_Direct& _internal_direct() const;
+  ::substrait::RelCommon_Direct* _internal_mutable_direct();
+  public:
+  void unsafe_arena_set_allocated_direct(
+      ::substrait::RelCommon_Direct* direct);
+  ::substrait::RelCommon_Direct* unsafe_arena_release_direct();
+
+  // .substrait.RelCommon.Emit emit = 2;
+  bool has_emit() const;
+  private:
+  bool _internal_has_emit() const;
+  public:
+  void clear_emit();
+  const ::substrait::RelCommon_Emit& emit() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon_Emit* release_emit();
+  ::substrait::RelCommon_Emit* mutable_emit();
+  void set_allocated_emit(::substrait::RelCommon_Emit* emit);
+  private:
+  const ::substrait::RelCommon_Emit& _internal_emit() const;
+  ::substrait::RelCommon_Emit* _internal_mutable_emit();
+  public:
+  void unsafe_arena_set_allocated_emit(
+      ::substrait::RelCommon_Emit* emit);
+  ::substrait::RelCommon_Emit* unsafe_arena_release_emit();
+
+  void clear_emit_kind();
+  EmitKindCase emit_kind_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.RelCommon)
+ private:
+  class _Internal;
+  void set_has_direct();
+  void set_has_emit();
+
+  inline bool has_emit_kind() const;
+  inline void clear_has_emit_kind();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::RelCommon_Hint* hint_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  union EmitKindUnion {
+    constexpr EmitKindUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::RelCommon_Direct* direct_;
+    ::substrait::RelCommon_Emit* emit_;
+  } emit_kind_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ReadRel_NamedTable final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.NamedTable) */ {
+ public:
+  inline ReadRel_NamedTable() : ReadRel_NamedTable(nullptr) {}
+  ~ReadRel_NamedTable() override;
+  explicit constexpr ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ReadRel_NamedTable(const ReadRel_NamedTable& from);
+  ReadRel_NamedTable(ReadRel_NamedTable&& from) noexcept
+    : ReadRel_NamedTable() {
+    *this = ::std::move(from);
+  }
+
+  inline ReadRel_NamedTable& operator=(const ReadRel_NamedTable& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ReadRel_NamedTable& operator=(ReadRel_NamedTable&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ReadRel_NamedTable& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ReadRel_NamedTable* internal_default_instance() {
+    return reinterpret_cast<const ReadRel_NamedTable*>(
+               &_ReadRel_NamedTable_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(ReadRel_NamedTable& a, ReadRel_NamedTable& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ReadRel_NamedTable* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ReadRel_NamedTable* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ReadRel_NamedTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ReadRel_NamedTable>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ReadRel_NamedTable& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ReadRel_NamedTable& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ReadRel_NamedTable* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ReadRel.NamedTable";
+  }
+  protected:
+  explicit ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNamesFieldNumber = 1,
+    kAdvancedExtensionFieldNumber = 10,
+  };
+  // repeated string names = 1;
+  int names_size() const;
+  private:
+  int _internal_names_size() const;
+  public:
+  void clear_names();
+  const std::string& names(int index) const;
+  std::string* mutable_names(int index);
+  void set_names(int index, const std::string& value);
+  void set_names(int index, std::string&& value);
+  void set_names(int index, const char* value);
+  void set_names(int index, const char* value, size_t size);
+  std::string* add_names();
+  void add_names(const std::string& value);
+  void add_names(std::string&& value);
+  void add_names(const char* value);
+  void add_names(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& names() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_names();
+  private:
+  const std::string& _internal_names(int index) const;
+  std::string* _internal_add_names();
+  public:
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // @@protoc_insertion_point(class_scope:substrait.ReadRel.NamedTable)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> names_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ReadRel_VirtualTable final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.VirtualTable) */ {
+ public:
+  inline ReadRel_VirtualTable() : ReadRel_VirtualTable(nullptr) {}
+  ~ReadRel_VirtualTable() override;
+  explicit constexpr ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ReadRel_VirtualTable(const ReadRel_VirtualTable& from);
+  ReadRel_VirtualTable(ReadRel_VirtualTable&& from) noexcept
+    : ReadRel_VirtualTable() {
+    *this = ::std::move(from);
+  }
+
+  inline ReadRel_VirtualTable& operator=(const ReadRel_VirtualTable& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ReadRel_VirtualTable& operator=(ReadRel_VirtualTable&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ReadRel_VirtualTable& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ReadRel_VirtualTable* internal_default_instance() {
+    return reinterpret_cast<const ReadRel_VirtualTable*>(
+               &_ReadRel_VirtualTable_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(ReadRel_VirtualTable& a, ReadRel_VirtualTable& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ReadRel_VirtualTable* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ReadRel_VirtualTable* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ReadRel_VirtualTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ReadRel_VirtualTable>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ReadRel_VirtualTable& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ReadRel_VirtualTable& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ReadRel_VirtualTable* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ReadRel.VirtualTable";
+  }
+  protected:
+  explicit ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValuesFieldNumber = 1,
+  };
+  // repeated .substrait.Expression.Literal.Struct values = 1;
+  int values_size() const;
+  private:
+  int _internal_values_size() const;
+  public:
+  void clear_values();
+  ::substrait::Expression_Literal_Struct* mutable_values(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >*
+      mutable_values();
+  private:
+  const ::substrait::Expression_Literal_Struct& _internal_values(int index) const;
+  ::substrait::Expression_Literal_Struct* _internal_add_values();
+  public:
+  const ::substrait::Expression_Literal_Struct& values(int index) const;
+  ::substrait::Expression_Literal_Struct* add_values();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >&
+      values() const;
+
+  // @@protoc_insertion_point(class_scope:substrait.ReadRel.VirtualTable)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct > values_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ReadRel_ExtensionTable final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.ExtensionTable) */ {
+ public:
+  inline ReadRel_ExtensionTable() : ReadRel_ExtensionTable(nullptr) {}
+  ~ReadRel_ExtensionTable() override;
+  explicit constexpr ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ReadRel_ExtensionTable(const ReadRel_ExtensionTable& from);
+  ReadRel_ExtensionTable(ReadRel_ExtensionTable&& from) noexcept
+    : ReadRel_ExtensionTable() {
+    *this = ::std::move(from);
+  }
+
+  inline ReadRel_ExtensionTable& operator=(const ReadRel_ExtensionTable& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ReadRel_ExtensionTable& operator=(ReadRel_ExtensionTable&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ReadRel_ExtensionTable& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ReadRel_ExtensionTable* internal_default_instance() {
+    return reinterpret_cast<const ReadRel_ExtensionTable*>(
+               &_ReadRel_ExtensionTable_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(ReadRel_ExtensionTable& a, ReadRel_ExtensionTable& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ReadRel_ExtensionTable* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ReadRel_ExtensionTable* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ReadRel_ExtensionTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ReadRel_ExtensionTable>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ReadRel_ExtensionTable& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ReadRel_ExtensionTable& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ReadRel_ExtensionTable* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ReadRel.ExtensionTable";
+  }
+  protected:
+  explicit ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDetailFieldNumber = 1,
+  };
+  // .google.protobuf.Any detail = 1;
+  bool has_detail() const;
+  private:
+  bool _internal_has_detail() const;
+  public:
+  void clear_detail();
+  const ::PROTOBUF_NAMESPACE_ID::Any& detail() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_detail();
+  ::PROTOBUF_NAMESPACE_ID::Any* mutable_detail();
+  void set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const;
+  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail();
+  public:
+  void unsafe_arena_set_allocated_detail(
+      ::PROTOBUF_NAMESPACE_ID::Any* detail);
+  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail();
+
+  // @@protoc_insertion_point(class_scope:substrait.ReadRel.ExtensionTable)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::Any* detail_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ReadRel_LocalFiles_FileOrFiles final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.LocalFiles.FileOrFiles) */ {
+ public:
+  inline ReadRel_LocalFiles_FileOrFiles() : ReadRel_LocalFiles_FileOrFiles(nullptr) {}
+  ~ReadRel_LocalFiles_FileOrFiles() override;
+  explicit constexpr ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ReadRel_LocalFiles_FileOrFiles(const ReadRel_LocalFiles_FileOrFiles& from);
+  ReadRel_LocalFiles_FileOrFiles(ReadRel_LocalFiles_FileOrFiles&& from) noexcept
+    : ReadRel_LocalFiles_FileOrFiles() {
+    *this = ::std::move(from);
+  }
+
+  inline ReadRel_LocalFiles_FileOrFiles& operator=(const ReadRel_LocalFiles_FileOrFiles& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ReadRel_LocalFiles_FileOrFiles& operator=(ReadRel_LocalFiles_FileOrFiles&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ReadRel_LocalFiles_FileOrFiles& default_instance() {
+    return *internal_default_instance();
+  }
+  enum PathTypeCase {
+    kUriPath = 1,
+    kUriPathGlob = 2,
+    kUriFile = 3,
+    kUriFolder = 4,
+    PATH_TYPE_NOT_SET = 0,
+  };
+
+  static inline const ReadRel_LocalFiles_FileOrFiles* internal_default_instance() {
+    return reinterpret_cast<const ReadRel_LocalFiles_FileOrFiles*>(
+               &_ReadRel_LocalFiles_FileOrFiles_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(ReadRel_LocalFiles_FileOrFiles& a, ReadRel_LocalFiles_FileOrFiles& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ReadRel_LocalFiles_FileOrFiles* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ReadRel_LocalFiles_FileOrFiles* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ReadRel_LocalFiles_FileOrFiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ReadRel_LocalFiles_FileOrFiles>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ReadRel_LocalFiles_FileOrFiles& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ReadRel_LocalFiles_FileOrFiles& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ReadRel_LocalFiles_FileOrFiles* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ReadRel.LocalFiles.FileOrFiles";
+  }
+  protected:
+  explicit ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ReadRel_LocalFiles_FileOrFiles_FileFormat FileFormat;
+  static constexpr FileFormat FILE_FORMAT_UNSPECIFIED =
+    ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_UNSPECIFIED;
+  static constexpr FileFormat FILE_FORMAT_PARQUET =
+    ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_PARQUET;
+  static inline bool FileFormat_IsValid(int value) {
+    return ReadRel_LocalFiles_FileOrFiles_FileFormat_IsValid(value);
+  }
+  static constexpr FileFormat FileFormat_MIN =
+    ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MIN;
+  static constexpr FileFormat FileFormat_MAX =
+    ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MAX;
+  static constexpr int FileFormat_ARRAYSIZE =
+    ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  FileFormat_descriptor() {
+    return ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& FileFormat_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, FileFormat>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function FileFormat_Name.");
+    return ReadRel_LocalFiles_FileOrFiles_FileFormat_Name(enum_t_value);
+  }
+  static inline bool FileFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      FileFormat* value) {
+    return ReadRel_LocalFiles_FileOrFiles_FileFormat_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFormatFieldNumber = 5,
+    kPartitionIndexFieldNumber = 6,
+    kStartFieldNumber = 7,
+    kLengthFieldNumber = 8,
+    kUriPathFieldNumber = 1,
+    kUriPathGlobFieldNumber = 2,
+    kUriFileFieldNumber = 3,
+    kUriFolderFieldNumber = 4,
+  };
+  // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5;
+  void clear_format();
+  ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat format() const;
+  void set_format(::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat value);
+  private:
+  ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat _internal_format() const;
+  void _internal_set_format(::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat value);
+  public:
+
+  // uint64 partition_index = 6;
+  void clear_partition_index();
+  uint64_t partition_index() const;
+  void set_partition_index(uint64_t value);
+  private:
+  uint64_t _internal_partition_index() const;
+  void _internal_set_partition_index(uint64_t value);
+  public:
+
+  // uint64 start = 7;
+  void clear_start();
+  uint64_t start() const;
+  void set_start(uint64_t value);
+  private:
+  uint64_t _internal_start() const;
+  void _internal_set_start(uint64_t value);
+  public:
+
+  // uint64 length = 8;
+  void clear_length();
+  uint64_t length() const;
+  void set_length(uint64_t value);
+  private:
+  uint64_t _internal_length() const;
+  void _internal_set_length(uint64_t value);
+  public:
+
+  // string uri_path = 1;
+  bool has_uri_path() const;
+  private:
+  bool _internal_has_uri_path() const;
+  public:
+  void clear_uri_path();
+  const std::string& uri_path() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_uri_path(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_uri_path();
+  PROTOBUF_NODISCARD std::string* release_uri_path();
+  void set_allocated_uri_path(std::string* uri_path);
+  private:
+  const std::string& _internal_uri_path() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri_path(const std::string& value);
+  std::string* _internal_mutable_uri_path();
+  public:
+
+  // string uri_path_glob = 2;
+  bool has_uri_path_glob() const;
+  private:
+  bool _internal_has_uri_path_glob() const;
+  public:
+  void clear_uri_path_glob();
+  const std::string& uri_path_glob() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_uri_path_glob(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_uri_path_glob();
+  PROTOBUF_NODISCARD std::string* release_uri_path_glob();
+  void set_allocated_uri_path_glob(std::string* uri_path_glob);
+  private:
+  const std::string& _internal_uri_path_glob() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri_path_glob(const std::string& value);
+  std::string* _internal_mutable_uri_path_glob();
+  public:
+
+  // string uri_file = 3;
+  bool has_uri_file() const;
+  private:
+  bool _internal_has_uri_file() const;
+  public:
+  void clear_uri_file();
+  const std::string& uri_file() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_uri_file(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_uri_file();
+  PROTOBUF_NODISCARD std::string* release_uri_file();
+  void set_allocated_uri_file(std::string* uri_file);
+  private:
+  const std::string& _internal_uri_file() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri_file(const std::string& value);
+  std::string* _internal_mutable_uri_file();
+  public:
+
+  // string uri_folder = 4;
+  bool has_uri_folder() const;
+  private:
+  bool _internal_has_uri_folder() const;
+  public:
+  void clear_uri_folder();
+  const std::string& uri_folder() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_uri_folder(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_uri_folder();
+  PROTOBUF_NODISCARD std::string* release_uri_folder();
+  void set_allocated_uri_folder(std::string* uri_folder);
+  private:
+  const std::string& _internal_uri_folder() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri_folder(const std::string& value);
+  std::string* _internal_mutable_uri_folder();
+  public:
+
+  void clear_path_type();
+  PathTypeCase path_type_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.ReadRel.LocalFiles.FileOrFiles)
+ private:
+  class _Internal;
+  void set_has_uri_path();
+  void set_has_uri_path_glob();
+  void set_has_uri_file();
+  void set_has_uri_folder();
+
+  inline bool has_path_type() const;
+  inline void clear_has_path_type();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int format_;
+  uint64_t partition_index_;
+  uint64_t start_;
+  uint64_t length_;
+  union PathTypeUnion {
+    constexpr PathTypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_path_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_path_glob_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_file_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_folder_;
+  } path_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ReadRel_LocalFiles final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.LocalFiles) */ {
+ public:
+  inline ReadRel_LocalFiles() : ReadRel_LocalFiles(nullptr) {}
+  ~ReadRel_LocalFiles() override;
+  explicit constexpr ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ReadRel_LocalFiles(const ReadRel_LocalFiles& from);
+  ReadRel_LocalFiles(ReadRel_LocalFiles&& from) noexcept
+    : ReadRel_LocalFiles() {
+    *this = ::std::move(from);
+  }
+
+  inline ReadRel_LocalFiles& operator=(const ReadRel_LocalFiles& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ReadRel_LocalFiles& operator=(ReadRel_LocalFiles&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ReadRel_LocalFiles& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ReadRel_LocalFiles* internal_default_instance() {
+    return reinterpret_cast<const ReadRel_LocalFiles*>(
+               &_ReadRel_LocalFiles_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(ReadRel_LocalFiles& a, ReadRel_LocalFiles& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ReadRel_LocalFiles* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ReadRel_LocalFiles* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ReadRel_LocalFiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ReadRel_LocalFiles>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ReadRel_LocalFiles& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ReadRel_LocalFiles& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ReadRel_LocalFiles* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ReadRel.LocalFiles";
+  }
+  protected:
+  explicit ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ReadRel_LocalFiles_FileOrFiles FileOrFiles;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kItemsFieldNumber = 1,
+    kAdvancedExtensionFieldNumber = 10,
+  };
+  // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1;
+  int items_size() const;
+  private:
+  int _internal_items_size() const;
+  public:
+  void clear_items();
+  ::substrait::ReadRel_LocalFiles_FileOrFiles* mutable_items(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >*
+      mutable_items();
+  private:
+  const ::substrait::ReadRel_LocalFiles_FileOrFiles& _internal_items(int index) const;
+  ::substrait::ReadRel_LocalFiles_FileOrFiles* _internal_add_items();
+  public:
+  const ::substrait::ReadRel_LocalFiles_FileOrFiles& items(int index) const;
+  ::substrait::ReadRel_LocalFiles_FileOrFiles* add_items();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >&
+      items() const;
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // @@protoc_insertion_point(class_scope:substrait.ReadRel.LocalFiles)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles > items_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ReadRel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel) */ {
+ public:
+  inline ReadRel() : ReadRel(nullptr) {}
+  ~ReadRel() override;
+  explicit constexpr ReadRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ReadRel(const ReadRel& from);
+  ReadRel(ReadRel&& from) noexcept
+    : ReadRel() {
+    *this = ::std::move(from);
+  }
+
+  inline ReadRel& operator=(const ReadRel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ReadRel& operator=(ReadRel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ReadRel& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ReadTypeCase {
+    kVirtualTable = 5,
+    kLocalFiles = 6,
+    kNamedTable = 7,
+    kExtensionTable = 8,
+    READ_TYPE_NOT_SET = 0,
+  };
+
+  static inline const ReadRel* internal_default_instance() {
+    return reinterpret_cast<const ReadRel*>(
+               &_ReadRel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(ReadRel& a, ReadRel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ReadRel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ReadRel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ReadRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ReadRel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ReadRel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ReadRel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ReadRel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ReadRel";
+  }
+  protected:
+  explicit ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ReadRel_NamedTable NamedTable;
+  typedef ReadRel_VirtualTable VirtualTable;
+  typedef ReadRel_ExtensionTable ExtensionTable;
+  typedef ReadRel_LocalFiles LocalFiles;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCommonFieldNumber = 1,
+    kBaseSchemaFieldNumber = 2,
+    kFilterFieldNumber = 3,
+    kProjectionFieldNumber = 4,
+    kAdvancedExtensionFieldNumber = 10,
+    kVirtualTableFieldNumber = 5,
+    kLocalFilesFieldNumber = 6,
+    kNamedTableFieldNumber = 7,
+    kExtensionTableFieldNumber = 8,
+  };
+  // .substrait.RelCommon common = 1;
+  bool has_common() const;
+  private:
+  bool _internal_has_common() const;
+  public:
+  void clear_common();
+  const ::substrait::RelCommon& common() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon* release_common();
+  ::substrait::RelCommon* mutable_common();
+  void set_allocated_common(::substrait::RelCommon* common);
+  private:
+  const ::substrait::RelCommon& _internal_common() const;
+  ::substrait::RelCommon* _internal_mutable_common();
+  public:
+  void unsafe_arena_set_allocated_common(
+      ::substrait::RelCommon* common);
+  ::substrait::RelCommon* unsafe_arena_release_common();
+
+  // .substrait.NamedStruct base_schema = 2;
+  bool has_base_schema() const;
+  private:
+  bool _internal_has_base_schema() const;
+  public:
+  void clear_base_schema();
+  const ::substrait::NamedStruct& base_schema() const;
+  PROTOBUF_NODISCARD ::substrait::NamedStruct* release_base_schema();
+  ::substrait::NamedStruct* mutable_base_schema();
+  void set_allocated_base_schema(::substrait::NamedStruct* base_schema);
+  private:
+  const ::substrait::NamedStruct& _internal_base_schema() const;
+  ::substrait::NamedStruct* _internal_mutable_base_schema();
+  public:
+  void unsafe_arena_set_allocated_base_schema(
+      ::substrait::NamedStruct* base_schema);
+  ::substrait::NamedStruct* unsafe_arena_release_base_schema();
+
+  // .substrait.Expression filter = 3;
+  bool has_filter() const;
+  private:
+  bool _internal_has_filter() const;
+  public:
+  void clear_filter();
+  const ::substrait::Expression& filter() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_filter();
+  ::substrait::Expression* mutable_filter();
+  void set_allocated_filter(::substrait::Expression* filter);
+  private:
+  const ::substrait::Expression& _internal_filter() const;
+  ::substrait::Expression* _internal_mutable_filter();
+  public:
+  void unsafe_arena_set_allocated_filter(
+      ::substrait::Expression* filter);
+  ::substrait::Expression* unsafe_arena_release_filter();
+
+  // .substrait.Expression.MaskExpression projection = 4;
+  bool has_projection() const;
+  private:
+  bool _internal_has_projection() const;
+  public:
+  void clear_projection();
+  const ::substrait::Expression_MaskExpression& projection() const;
+  PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression* release_projection();
+  ::substrait::Expression_MaskExpression* mutable_projection();
+  void set_allocated_projection(::substrait::Expression_MaskExpression* projection);
+  private:
+  const ::substrait::Expression_MaskExpression& _internal_projection() const;
+  ::substrait::Expression_MaskExpression* _internal_mutable_projection();
+  public:
+  void unsafe_arena_set_allocated_projection(
+      ::substrait::Expression_MaskExpression* projection);
+  ::substrait::Expression_MaskExpression* unsafe_arena_release_projection();
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // .substrait.ReadRel.VirtualTable virtual_table = 5;
+  bool has_virtual_table() const;
+  private:
+  bool _internal_has_virtual_table() const;
+  public:
+  void clear_virtual_table();
+  const ::substrait::ReadRel_VirtualTable& virtual_table() const;
+  PROTOBUF_NODISCARD ::substrait::ReadRel_VirtualTable* release_virtual_table();
+  ::substrait::ReadRel_VirtualTable* mutable_virtual_table();
+  void set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* virtual_table);
+  private:
+  const ::substrait::ReadRel_VirtualTable& _internal_virtual_table() const;
+  ::substrait::ReadRel_VirtualTable* _internal_mutable_virtual_table();
+  public:
+  void unsafe_arena_set_allocated_virtual_table(
+      ::substrait::ReadRel_VirtualTable* virtual_table);
+  ::substrait::ReadRel_VirtualTable* unsafe_arena_release_virtual_table();
+
+  // .substrait.ReadRel.LocalFiles local_files = 6;
+  bool has_local_files() const;
+  private:
+  bool _internal_has_local_files() const;
+  public:
+  void clear_local_files();
+  const ::substrait::ReadRel_LocalFiles& local_files() const;
+  PROTOBUF_NODISCARD ::substrait::ReadRel_LocalFiles* release_local_files();
+  ::substrait::ReadRel_LocalFiles* mutable_local_files();
+  void set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_files);
+  private:
+  const ::substrait::ReadRel_LocalFiles& _internal_local_files() const;
+  ::substrait::ReadRel_LocalFiles* _internal_mutable_local_files();
+  public:
+  void unsafe_arena_set_allocated_local_files(
+      ::substrait::ReadRel_LocalFiles* local_files);
+  ::substrait::ReadRel_LocalFiles* unsafe_arena_release_local_files();
+
+  // .substrait.ReadRel.NamedTable named_table = 7;
+  bool has_named_table() const;
+  private:
+  bool _internal_has_named_table() const;
+  public:
+  void clear_named_table();
+  const ::substrait::ReadRel_NamedTable& named_table() const;
+  PROTOBUF_NODISCARD ::substrait::ReadRel_NamedTable* release_named_table();
+  ::substrait::ReadRel_NamedTable* mutable_named_table();
+  void set_allocated_named_table(::substrait::ReadRel_NamedTable* named_table);
+  private:
+  const ::substrait::ReadRel_NamedTable& _internal_named_table() const;
+  ::substrait::ReadRel_NamedTable* _internal_mutable_named_table();
+  public:
+  void unsafe_arena_set_allocated_named_table(
+      ::substrait::ReadRel_NamedTable* named_table);
+  ::substrait::ReadRel_NamedTable* unsafe_arena_release_named_table();
+
+  // .substrait.ReadRel.ExtensionTable extension_table = 8;
+  bool has_extension_table() const;
+  private:
+  bool _internal_has_extension_table() const;
+  public:
+  void clear_extension_table();
+  const ::substrait::ReadRel_ExtensionTable& extension_table() const;
+  PROTOBUF_NODISCARD ::substrait::ReadRel_ExtensionTable* release_extension_table();
+  ::substrait::ReadRel_ExtensionTable* mutable_extension_table();
+  void set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* extension_table);
+  private:
+  const ::substrait::ReadRel_ExtensionTable& _internal_extension_table() const;
+  ::substrait::ReadRel_ExtensionTable* _internal_mutable_extension_table();
+  public:
+  void unsafe_arena_set_allocated_extension_table(
+      ::substrait::ReadRel_ExtensionTable* extension_table);
+  ::substrait::ReadRel_ExtensionTable* unsafe_arena_release_extension_table();
+
+  void clear_read_type();
+  ReadTypeCase read_type_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.ReadRel)
+ private:
+  class _Internal;
+  void set_has_virtual_table();
+  void set_has_local_files();
+  void set_has_named_table();
+  void set_has_extension_table();
+
+  inline bool has_read_type() const;
+  inline void clear_has_read_type();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::RelCommon* common_;
+  ::substrait::NamedStruct* base_schema_;
+  ::substrait::Expression* filter_;
+  ::substrait::Expression_MaskExpression* projection_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  union ReadTypeUnion {
+    constexpr ReadTypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::ReadRel_VirtualTable* virtual_table_;
+    ::substrait::ReadRel_LocalFiles* local_files_;
+    ::substrait::ReadRel_NamedTable* named_table_;
+    ::substrait::ReadRel_ExtensionTable* extension_table_;
+  } read_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProjectRel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ProjectRel) */ {
+ public:
+  inline ProjectRel() : ProjectRel(nullptr) {}
+  ~ProjectRel() override;
+  explicit constexpr ProjectRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProjectRel(const ProjectRel& from);
+  ProjectRel(ProjectRel&& from) noexcept
+    : ProjectRel() {
+    *this = ::std::move(from);
+  }
+
+  inline ProjectRel& operator=(const ProjectRel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProjectRel& operator=(ProjectRel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProjectRel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProjectRel* internal_default_instance() {
+    return reinterpret_cast<const ProjectRel*>(
+               &_ProjectRel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(ProjectRel& a, ProjectRel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProjectRel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProjectRel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ProjectRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ProjectRel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProjectRel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProjectRel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProjectRel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ProjectRel";
+  }
+  protected:
+  explicit ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kExpressionsFieldNumber = 3,
+    kCommonFieldNumber = 1,
+    kInputFieldNumber = 2,
+    kAdvancedExtensionFieldNumber = 10,
+  };
+  // repeated .substrait.Expression expressions = 3;
+  int expressions_size() const;
+  private:
+  int _internal_expressions_size() const;
+  public:
+  void clear_expressions();
+  ::substrait::Expression* mutable_expressions(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+      mutable_expressions();
+  private:
+  const ::substrait::Expression& _internal_expressions(int index) const;
+  ::substrait::Expression* _internal_add_expressions();
+  public:
+  const ::substrait::Expression& expressions(int index) const;
+  ::substrait::Expression* add_expressions();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+      expressions() const;
+
+  // .substrait.RelCommon common = 1;
+  bool has_common() const;
+  private:
+  bool _internal_has_common() const;
+  public:
+  void clear_common();
+  const ::substrait::RelCommon& common() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon* release_common();
+  ::substrait::RelCommon* mutable_common();
+  void set_allocated_common(::substrait::RelCommon* common);
+  private:
+  const ::substrait::RelCommon& _internal_common() const;
+  ::substrait::RelCommon* _internal_mutable_common();
+  public:
+  void unsafe_arena_set_allocated_common(
+      ::substrait::RelCommon* common);
+  ::substrait::RelCommon* unsafe_arena_release_common();
+
+  // .substrait.Rel input = 2;
+  bool has_input() const;
+  private:
+  bool _internal_has_input() const;
+  public:
+  void clear_input();
+  const ::substrait::Rel& input() const;
+  PROTOBUF_NODISCARD ::substrait::Rel* release_input();
+  ::substrait::Rel* mutable_input();
+  void set_allocated_input(::substrait::Rel* input);
+  private:
+  const ::substrait::Rel& _internal_input() const;
+  ::substrait::Rel* _internal_mutable_input();
+  public:
+  void unsafe_arena_set_allocated_input(
+      ::substrait::Rel* input);
+  ::substrait::Rel* unsafe_arena_release_input();
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // @@protoc_insertion_point(class_scope:substrait.ProjectRel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > expressions_;
+  ::substrait::RelCommon* common_;
+  ::substrait::Rel* input_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class JoinRel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.JoinRel) */ {
+ public:
+  inline JoinRel() : JoinRel(nullptr) {}
+  ~JoinRel() override;
+  explicit constexpr JoinRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  JoinRel(const JoinRel& from);
+  JoinRel(JoinRel&& from) noexcept
+    : JoinRel() {
+    *this = ::std::move(from);
+  }
+
+  inline JoinRel& operator=(const JoinRel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline JoinRel& operator=(JoinRel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const JoinRel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const JoinRel* internal_default_instance() {
+    return reinterpret_cast<const JoinRel*>(
+               &_JoinRel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(JoinRel& a, JoinRel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(JoinRel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(JoinRel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  JoinRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<JoinRel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const JoinRel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const JoinRel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(JoinRel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.JoinRel";
+  }
+  protected:
+  explicit JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef JoinRel_JoinType JoinType;
+  static constexpr JoinType JOIN_TYPE_UNSPECIFIED =
+    JoinRel_JoinType_JOIN_TYPE_UNSPECIFIED;
+  static constexpr JoinType JOIN_TYPE_INNER =
+    JoinRel_JoinType_JOIN_TYPE_INNER;
+  static constexpr JoinType JOIN_TYPE_OUTER =
+    JoinRel_JoinType_JOIN_TYPE_OUTER;
+  static constexpr JoinType JOIN_TYPE_LEFT =
+    JoinRel_JoinType_JOIN_TYPE_LEFT;
+  static constexpr JoinType JOIN_TYPE_RIGHT =
+    JoinRel_JoinType_JOIN_TYPE_RIGHT;
+  static constexpr JoinType JOIN_TYPE_SEMI =
+    JoinRel_JoinType_JOIN_TYPE_SEMI;
+  static constexpr JoinType JOIN_TYPE_ANTI =
+    JoinRel_JoinType_JOIN_TYPE_ANTI;
+  static inline bool JoinType_IsValid(int value) {
+    return JoinRel_JoinType_IsValid(value);
+  }
+  static constexpr JoinType JoinType_MIN =
+    JoinRel_JoinType_JoinType_MIN;
+  static constexpr JoinType JoinType_MAX =
+    JoinRel_JoinType_JoinType_MAX;
+  static constexpr int JoinType_ARRAYSIZE =
+    JoinRel_JoinType_JoinType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  JoinType_descriptor() {
+    return JoinRel_JoinType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& JoinType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, JoinType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function JoinType_Name.");
+    return JoinRel_JoinType_Name(enum_t_value);
+  }
+  static inline bool JoinType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      JoinType* value) {
+    return JoinRel_JoinType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCommonFieldNumber = 1,
+    kLeftFieldNumber = 2,
+    kRightFieldNumber = 3,
+    kExpressionFieldNumber = 4,
+    kPostJoinFilterFieldNumber = 5,
+    kAdvancedExtensionFieldNumber = 10,
+    kTypeFieldNumber = 6,
+  };
+  // .substrait.RelCommon common = 1;
+  bool has_common() const;
+  private:
+  bool _internal_has_common() const;
+  public:
+  void clear_common();
+  const ::substrait::RelCommon& common() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon* release_common();
+  ::substrait::RelCommon* mutable_common();
+  void set_allocated_common(::substrait::RelCommon* common);
+  private:
+  const ::substrait::RelCommon& _internal_common() const;
+  ::substrait::RelCommon* _internal_mutable_common();
+  public:
+  void unsafe_arena_set_allocated_common(
+      ::substrait::RelCommon* common);
+  ::substrait::RelCommon* unsafe_arena_release_common();
+
+  // .substrait.Rel left = 2;
+  bool has_left() const;
+  private:
+  bool _internal_has_left() const;
+  public:
+  void clear_left();
+  const ::substrait::Rel& left() const;
+  PROTOBUF_NODISCARD ::substrait::Rel* release_left();
+  ::substrait::Rel* mutable_left();
+  void set_allocated_left(::substrait::Rel* left);
+  private:
+  const ::substrait::Rel& _internal_left() const;
+  ::substrait::Rel* _internal_mutable_left();
+  public:
+  void unsafe_arena_set_allocated_left(
+      ::substrait::Rel* left);
+  ::substrait::Rel* unsafe_arena_release_left();
+
+  // .substrait.Rel right = 3;
+  bool has_right() const;
+  private:
+  bool _internal_has_right() const;
+  public:
+  void clear_right();
+  const ::substrait::Rel& right() const;
+  PROTOBUF_NODISCARD ::substrait::Rel* release_right();
+  ::substrait::Rel* mutable_right();
+  void set_allocated_right(::substrait::Rel* right);
+  private:
+  const ::substrait::Rel& _internal_right() const;
+  ::substrait::Rel* _internal_mutable_right();
+  public:
+  void unsafe_arena_set_allocated_right(
+      ::substrait::Rel* right);
+  ::substrait::Rel* unsafe_arena_release_right();
+
+  // .substrait.Expression expression = 4;
+  bool has_expression() const;
+  private:
+  bool _internal_has_expression() const;
+  public:
+  void clear_expression();
+  const ::substrait::Expression& expression() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_expression();
+  ::substrait::Expression* mutable_expression();
+  void set_allocated_expression(::substrait::Expression* expression);
+  private:
+  const ::substrait::Expression& _internal_expression() const;
+  ::substrait::Expression* _internal_mutable_expression();
+  public:
+  void unsafe_arena_set_allocated_expression(
+      ::substrait::Expression* expression);
+  ::substrait::Expression* unsafe_arena_release_expression();
+
+  // .substrait.Expression post_join_filter = 5;
+  bool has_post_join_filter() const;
+  private:
+  bool _internal_has_post_join_filter() const;
+  public:
+  void clear_post_join_filter();
+  const ::substrait::Expression& post_join_filter() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_post_join_filter();
+  ::substrait::Expression* mutable_post_join_filter();
+  void set_allocated_post_join_filter(::substrait::Expression* post_join_filter);
+  private:
+  const ::substrait::Expression& _internal_post_join_filter() const;
+  ::substrait::Expression* _internal_mutable_post_join_filter();
+  public:
+  void unsafe_arena_set_allocated_post_join_filter(
+      ::substrait::Expression* post_join_filter);
+  ::substrait::Expression* unsafe_arena_release_post_join_filter();
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // .substrait.JoinRel.JoinType type = 6;
+  void clear_type();
+  ::substrait::JoinRel_JoinType type() const;
+  void set_type(::substrait::JoinRel_JoinType value);
+  private:
+  ::substrait::JoinRel_JoinType _internal_type() const;
+  void _internal_set_type(::substrait::JoinRel_JoinType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.JoinRel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::RelCommon* common_;
+  ::substrait::Rel* left_;
+  ::substrait::Rel* right_;
+  ::substrait::Expression* expression_;
+  ::substrait::Expression* post_join_filter_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  int type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FetchRel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FetchRel) */ {
+ public:
+  inline FetchRel() : FetchRel(nullptr) {}
+  ~FetchRel() override;
+  explicit constexpr FetchRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FetchRel(const FetchRel& from);
+  FetchRel(FetchRel&& from) noexcept
+    : FetchRel() {
+    *this = ::std::move(from);
+  }
+
+  inline FetchRel& operator=(const FetchRel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FetchRel& operator=(FetchRel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FetchRel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FetchRel* internal_default_instance() {
+    return reinterpret_cast<const FetchRel*>(
+               &_FetchRel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(FetchRel& a, FetchRel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FetchRel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FetchRel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FetchRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FetchRel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FetchRel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const FetchRel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FetchRel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FetchRel";
+  }
+  protected:
+  explicit FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCommonFieldNumber = 1,
+    kInputFieldNumber = 2,
+    kAdvancedExtensionFieldNumber = 10,
+    kOffsetFieldNumber = 3,
+    kCountFieldNumber = 4,
+  };
+  // .substrait.RelCommon common = 1;
+  bool has_common() const;
+  private:
+  bool _internal_has_common() const;
+  public:
+  void clear_common();
+  const ::substrait::RelCommon& common() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon* release_common();
+  ::substrait::RelCommon* mutable_common();
+  void set_allocated_common(::substrait::RelCommon* common);
+  private:
+  const ::substrait::RelCommon& _internal_common() const;
+  ::substrait::RelCommon* _internal_mutable_common();
+  public:
+  void unsafe_arena_set_allocated_common(
+      ::substrait::RelCommon* common);
+  ::substrait::RelCommon* unsafe_arena_release_common();
+
+  // .substrait.Rel input = 2;
+  bool has_input() const;
+  private:
+  bool _internal_has_input() const;
+  public:
+  void clear_input();
+  const ::substrait::Rel& input() const;
+  PROTOBUF_NODISCARD ::substrait::Rel* release_input();
+  ::substrait::Rel* mutable_input();
+  void set_allocated_input(::substrait::Rel* input);
+  private:
+  const ::substrait::Rel& _internal_input() const;
+  ::substrait::Rel* _internal_mutable_input();
+  public:
+  void unsafe_arena_set_allocated_input(
+      ::substrait::Rel* input);
+  ::substrait::Rel* unsafe_arena_release_input();
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // int64 offset = 3;
+  void clear_offset();
+  int64_t offset() const;
+  void set_offset(int64_t value);
+  private:
+  int64_t _internal_offset() const;
+  void _internal_set_offset(int64_t value);
+  public:
+
+  // int64 count = 4;
+  void clear_count();
+  int64_t count() const;
+  void set_count(int64_t value);
+  private:
+  int64_t _internal_count() const;
+  void _internal_set_count(int64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.FetchRel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::RelCommon* common_;
+  ::substrait::Rel* input_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  int64_t offset_;
+  int64_t count_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AggregateRel_Grouping final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateRel.Grouping) */ {
+ public:
+  inline AggregateRel_Grouping() : AggregateRel_Grouping(nullptr) {}
+  ~AggregateRel_Grouping() override;
+  explicit constexpr AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AggregateRel_Grouping(const AggregateRel_Grouping& from);
+  AggregateRel_Grouping(AggregateRel_Grouping&& from) noexcept
+    : AggregateRel_Grouping() {
+    *this = ::std::move(from);
+  }
+
+  inline AggregateRel_Grouping& operator=(const AggregateRel_Grouping& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AggregateRel_Grouping& operator=(AggregateRel_Grouping&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AggregateRel_Grouping& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AggregateRel_Grouping* internal_default_instance() {
+    return reinterpret_cast<const AggregateRel_Grouping*>(
+               &_AggregateRel_Grouping_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(AggregateRel_Grouping& a, AggregateRel_Grouping& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AggregateRel_Grouping* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AggregateRel_Grouping* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AggregateRel_Grouping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AggregateRel_Grouping>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AggregateRel_Grouping& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const AggregateRel_Grouping& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AggregateRel_Grouping* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.AggregateRel.Grouping";
+  }
+  protected:
+  explicit AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kGroupingExpressionsFieldNumber = 1,
+  };
+  // repeated .substrait.Expression grouping_expressions = 1;
+  int grouping_expressions_size() const;
+  private:
+  int _internal_grouping_expressions_size() const;
+  public:
+  void clear_grouping_expressions();
+  ::substrait::Expression* mutable_grouping_expressions(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+      mutable_grouping_expressions();
+  private:
+  const ::substrait::Expression& _internal_grouping_expressions(int index) const;
+  ::substrait::Expression* _internal_add_grouping_expressions();
+  public:
+  const ::substrait::Expression& grouping_expressions(int index) const;
+  ::substrait::Expression* add_grouping_expressions();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+      grouping_expressions() const;
+
+  // @@protoc_insertion_point(class_scope:substrait.AggregateRel.Grouping)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > grouping_expressions_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AggregateRel_Measure final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateRel.Measure) */ {
+ public:
+  inline AggregateRel_Measure() : AggregateRel_Measure(nullptr) {}
+  ~AggregateRel_Measure() override;
+  explicit constexpr AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AggregateRel_Measure(const AggregateRel_Measure& from);
+  AggregateRel_Measure(AggregateRel_Measure&& from) noexcept
+    : AggregateRel_Measure() {
+    *this = ::std::move(from);
+  }
+
+  inline AggregateRel_Measure& operator=(const AggregateRel_Measure& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AggregateRel_Measure& operator=(AggregateRel_Measure&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AggregateRel_Measure& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AggregateRel_Measure* internal_default_instance() {
+    return reinterpret_cast<const AggregateRel_Measure*>(
+               &_AggregateRel_Measure_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(AggregateRel_Measure& a, AggregateRel_Measure& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AggregateRel_Measure* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AggregateRel_Measure* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AggregateRel_Measure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AggregateRel_Measure>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AggregateRel_Measure& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const AggregateRel_Measure& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AggregateRel_Measure* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.AggregateRel.Measure";
+  }
+  protected:
+  explicit AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMeasureFieldNumber = 1,
+    kFilterFieldNumber = 2,
+  };
+  // .substrait.AggregateFunction measure = 1;
+  bool has_measure() const;
+  private:
+  bool _internal_has_measure() const;
+  public:
+  void clear_measure();
+  const ::substrait::AggregateFunction& measure() const;
+  PROTOBUF_NODISCARD ::substrait::AggregateFunction* release_measure();
+  ::substrait::AggregateFunction* mutable_measure();
+  void set_allocated_measure(::substrait::AggregateFunction* measure);
+  private:
+  const ::substrait::AggregateFunction& _internal_measure() const;
+  ::substrait::AggregateFunction* _internal_mutable_measure();
+  public:
+  void unsafe_arena_set_allocated_measure(
+      ::substrait::AggregateFunction* measure);
+  ::substrait::AggregateFunction* unsafe_arena_release_measure();
+
+  // .substrait.Expression filter = 2;
+  bool has_filter() const;
+  private:
+  bool _internal_has_filter() const;
+  public:
+  void clear_filter();
+  const ::substrait::Expression& filter() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_filter();
+  ::substrait::Expression* mutable_filter();
+  void set_allocated_filter(::substrait::Expression* filter);
+  private:
+  const ::substrait::Expression& _internal_filter() const;
+  ::substrait::Expression* _internal_mutable_filter();
+  public:
+  void unsafe_arena_set_allocated_filter(
+      ::substrait::Expression* filter);
+  ::substrait::Expression* unsafe_arena_release_filter();
+
+  // @@protoc_insertion_point(class_scope:substrait.AggregateRel.Measure)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::AggregateFunction* measure_;
+  ::substrait::Expression* filter_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AggregateRel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateRel) */ {
+ public:
+  inline AggregateRel() : AggregateRel(nullptr) {}
+  ~AggregateRel() override;
+  explicit constexpr AggregateRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AggregateRel(const AggregateRel& from);
+  AggregateRel(AggregateRel&& from) noexcept
+    : AggregateRel() {
+    *this = ::std::move(from);
+  }
+
+  inline AggregateRel& operator=(const AggregateRel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AggregateRel& operator=(AggregateRel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AggregateRel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AggregateRel* internal_default_instance() {
+    return reinterpret_cast<const AggregateRel*>(
+               &_AggregateRel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(AggregateRel& a, AggregateRel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AggregateRel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AggregateRel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AggregateRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AggregateRel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AggregateRel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const AggregateRel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AggregateRel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.AggregateRel";
+  }
+  protected:
+  explicit AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef AggregateRel_Grouping Grouping;
+  typedef AggregateRel_Measure Measure;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kGroupingsFieldNumber = 3,
+    kMeasuresFieldNumber = 4,
+    kCommonFieldNumber = 1,
+    kInputFieldNumber = 2,
+    kAdvancedExtensionFieldNumber = 10,
+  };
+  // repeated .substrait.AggregateRel.Grouping groupings = 3;
+  int groupings_size() const;
+  private:
+  int _internal_groupings_size() const;
+  public:
+  void clear_groupings();
+  ::substrait::AggregateRel_Grouping* mutable_groupings(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >*
+      mutable_groupings();
+  private:
+  const ::substrait::AggregateRel_Grouping& _internal_groupings(int index) const;
+  ::substrait::AggregateRel_Grouping* _internal_add_groupings();
+  public:
+  const ::substrait::AggregateRel_Grouping& groupings(int index) const;
+  ::substrait::AggregateRel_Grouping* add_groupings();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >&
+      groupings() const;
+
+  // repeated .substrait.AggregateRel.Measure measures = 4;
+  int measures_size() const;
+  private:
+  int _internal_measures_size() const;
+  public:
+  void clear_measures();
+  ::substrait::AggregateRel_Measure* mutable_measures(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >*
+      mutable_measures();
+  private:
+  const ::substrait::AggregateRel_Measure& _internal_measures(int index) const;
+  ::substrait::AggregateRel_Measure* _internal_add_measures();
+  public:
+  const ::substrait::AggregateRel_Measure& measures(int index) const;
+  ::substrait::AggregateRel_Measure* add_measures();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >&
+      measures() const;
+
+  // .substrait.RelCommon common = 1;
+  bool has_common() const;
+  private:
+  bool _internal_has_common() const;
+  public:
+  void clear_common();
+  const ::substrait::RelCommon& common() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon* release_common();
+  ::substrait::RelCommon* mutable_common();
+  void set_allocated_common(::substrait::RelCommon* common);
+  private:
+  const ::substrait::RelCommon& _internal_common() const;
+  ::substrait::RelCommon* _internal_mutable_common();
+  public:
+  void unsafe_arena_set_allocated_common(
+      ::substrait::RelCommon* common);
+  ::substrait::RelCommon* unsafe_arena_release_common();
+
+  // .substrait.Rel input = 2;
+  bool has_input() const;
+  private:
+  bool _internal_has_input() const;
+  public:
+  void clear_input();
+  const ::substrait::Rel& input() const;
+  PROTOBUF_NODISCARD ::substrait::Rel* release_input();
+  ::substrait::Rel* mutable_input();
+  void set_allocated_input(::substrait::Rel* input);
+  private:
+  const ::substrait::Rel& _internal_input() const;
+  ::substrait::Rel* _internal_mutable_input();
+  public:
+  void unsafe_arena_set_allocated_input(
+      ::substrait::Rel* input);
+  ::substrait::Rel* unsafe_arena_release_input();
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // @@protoc_insertion_point(class_scope:substrait.AggregateRel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping > groupings_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure > measures_;
+  ::substrait::RelCommon* common_;
+  ::substrait::Rel* input_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SortRel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.SortRel) */ {
+ public:
+  inline SortRel() : SortRel(nullptr) {}
+  ~SortRel() override;
+  explicit constexpr SortRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SortRel(const SortRel& from);
+  SortRel(SortRel&& from) noexcept
+    : SortRel() {
+    *this = ::std::move(from);
+  }
+
+  inline SortRel& operator=(const SortRel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SortRel& operator=(SortRel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SortRel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SortRel* internal_default_instance() {
+    return reinterpret_cast<const SortRel*>(
+               &_SortRel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(SortRel& a, SortRel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SortRel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SortRel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SortRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SortRel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SortRel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SortRel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SortRel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.SortRel";
+  }
+  protected:
+  explicit SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSortsFieldNumber = 3,
+    kCommonFieldNumber = 1,
+    kInputFieldNumber = 2,
+    kAdvancedExtensionFieldNumber = 10,
+  };
+  // repeated .substrait.SortField sorts = 3;
+  int sorts_size() const;
+  private:
+  int _internal_sorts_size() const;
+  public:
+  void clear_sorts();
+  ::substrait::SortField* mutable_sorts(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >*
+      mutable_sorts();
+  private:
+  const ::substrait::SortField& _internal_sorts(int index) const;
+  ::substrait::SortField* _internal_add_sorts();
+  public:
+  const ::substrait::SortField& sorts(int index) const;
+  ::substrait::SortField* add_sorts();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >&
+      sorts() const;
+
+  // .substrait.RelCommon common = 1;
+  bool has_common() const;
+  private:
+  bool _internal_has_common() const;
+  public:
+  void clear_common();
+  const ::substrait::RelCommon& common() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon* release_common();
+  ::substrait::RelCommon* mutable_common();
+  void set_allocated_common(::substrait::RelCommon* common);
+  private:
+  const ::substrait::RelCommon& _internal_common() const;
+  ::substrait::RelCommon* _internal_mutable_common();
+  public:
+  void unsafe_arena_set_allocated_common(
+      ::substrait::RelCommon* common);
+  ::substrait::RelCommon* unsafe_arena_release_common();
+
+  // .substrait.Rel input = 2;
+  bool has_input() const;
+  private:
+  bool _internal_has_input() const;
+  public:
+  void clear_input();
+  const ::substrait::Rel& input() const;
+  PROTOBUF_NODISCARD ::substrait::Rel* release_input();
+  ::substrait::Rel* mutable_input();
+  void set_allocated_input(::substrait::Rel* input);
+  private:
+  const ::substrait::Rel& _internal_input() const;
+  ::substrait::Rel* _internal_mutable_input();
+  public:
+  void unsafe_arena_set_allocated_input(
+      ::substrait::Rel* input);
+  ::substrait::Rel* unsafe_arena_release_input();
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // @@protoc_insertion_point(class_scope:substrait.SortRel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField > sorts_;
+  ::substrait::RelCommon* common_;
+  ::substrait::Rel* input_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class FilterRel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FilterRel) */ {
+ public:
+  inline FilterRel() : FilterRel(nullptr) {}
+  ~FilterRel() override;
+  explicit constexpr FilterRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  FilterRel(const FilterRel& from);
+  FilterRel(FilterRel&& from) noexcept
+    : FilterRel() {
+    *this = ::std::move(from);
+  }
+
+  inline FilterRel& operator=(const FilterRel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline FilterRel& operator=(FilterRel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const FilterRel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const FilterRel* internal_default_instance() {
+    return reinterpret_cast<const FilterRel*>(
+               &_FilterRel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  friend void swap(FilterRel& a, FilterRel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(FilterRel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(FilterRel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  FilterRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<FilterRel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const FilterRel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const FilterRel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(FilterRel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.FilterRel";
+  }
+  protected:
+  explicit FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCommonFieldNumber = 1,
+    kInputFieldNumber = 2,
+    kConditionFieldNumber = 3,
+    kAdvancedExtensionFieldNumber = 10,
+  };
+  // .substrait.RelCommon common = 1;
+  bool has_common() const;
+  private:
+  bool _internal_has_common() const;
+  public:
+  void clear_common();
+  const ::substrait::RelCommon& common() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon* release_common();
+  ::substrait::RelCommon* mutable_common();
+  void set_allocated_common(::substrait::RelCommon* common);
+  private:
+  const ::substrait::RelCommon& _internal_common() const;
+  ::substrait::RelCommon* _internal_mutable_common();
+  public:
+  void unsafe_arena_set_allocated_common(
+      ::substrait::RelCommon* common);
+  ::substrait::RelCommon* unsafe_arena_release_common();
+
+  // .substrait.Rel input = 2;
+  bool has_input() const;
+  private:
+  bool _internal_has_input() const;
+  public:
+  void clear_input();
+  const ::substrait::Rel& input() const;
+  PROTOBUF_NODISCARD ::substrait::Rel* release_input();
+  ::substrait::Rel* mutable_input();
+  void set_allocated_input(::substrait::Rel* input);
+  private:
+  const ::substrait::Rel& _internal_input() const;
+  ::substrait::Rel* _internal_mutable_input();
+  public:
+  void unsafe_arena_set_allocated_input(
+      ::substrait::Rel* input);
+  ::substrait::Rel* unsafe_arena_release_input();
+
+  // .substrait.Expression condition = 3;
+  bool has_condition() const;
+  private:
+  bool _internal_has_condition() const;
+  public:
+  void clear_condition();
+  const ::substrait::Expression& condition() const;
+  PROTOBUF_NODISCARD ::substrait::Expression* release_condition();
+  ::substrait::Expression* mutable_condition();
+  void set_allocated_condition(::substrait::Expression* condition);
+  private:
+  const ::substrait::Expression& _internal_condition() const;
+  ::substrait::Expression* _internal_mutable_condition();
+  public:
+  void unsafe_arena_set_allocated_condition(
+      ::substrait::Expression* condition);
+  ::substrait::Expression* unsafe_arena_release_condition();
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // @@protoc_insertion_point(class_scope:substrait.FilterRel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::RelCommon* common_;
+  ::substrait::Rel* input_;
+  ::substrait::Expression* condition_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SetRel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.SetRel) */ {
+ public:
+  inline SetRel() : SetRel(nullptr) {}
+  ~SetRel() override;
+  explicit constexpr SetRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SetRel(const SetRel& from);
+  SetRel(SetRel&& from) noexcept
+    : SetRel() {
+    *this = ::std::move(from);
+  }
+
+  inline SetRel& operator=(const SetRel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SetRel& operator=(SetRel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SetRel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SetRel* internal_default_instance() {
+    return reinterpret_cast<const SetRel*>(
+               &_SetRel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  friend void swap(SetRel& a, SetRel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SetRel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SetRel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  SetRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<SetRel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SetRel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SetRel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SetRel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.SetRel";
+  }
+  protected:
+  explicit SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SetRel_SetOp SetOp;
+  static constexpr SetOp SET_OP_UNSPECIFIED =
+    SetRel_SetOp_SET_OP_UNSPECIFIED;
+  static constexpr SetOp SET_OP_MINUS_PRIMARY =
+    SetRel_SetOp_SET_OP_MINUS_PRIMARY;
+  static constexpr SetOp SET_OP_MINUS_MULTISET =
+    SetRel_SetOp_SET_OP_MINUS_MULTISET;
+  static constexpr SetOp SET_OP_INTERSECTION_PRIMARY =
+    SetRel_SetOp_SET_OP_INTERSECTION_PRIMARY;
+  static constexpr SetOp SET_OP_INTERSECTION_MULTISET =
+    SetRel_SetOp_SET_OP_INTERSECTION_MULTISET;
+  static constexpr SetOp SET_OP_UNION_DISTINCT =
+    SetRel_SetOp_SET_OP_UNION_DISTINCT;
+  static constexpr SetOp SET_OP_UNION_ALL =
+    SetRel_SetOp_SET_OP_UNION_ALL;
+  static inline bool SetOp_IsValid(int value) {
+    return SetRel_SetOp_IsValid(value);
+  }
+  static constexpr SetOp SetOp_MIN =
+    SetRel_SetOp_SetOp_MIN;
+  static constexpr SetOp SetOp_MAX =
+    SetRel_SetOp_SetOp_MAX;
+  static constexpr int SetOp_ARRAYSIZE =
+    SetRel_SetOp_SetOp_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  SetOp_descriptor() {
+    return SetRel_SetOp_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& SetOp_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SetOp>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SetOp_Name.");
+    return SetRel_SetOp_Name(enum_t_value);
+  }
+  static inline bool SetOp_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SetOp* value) {
+    return SetRel_SetOp_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kInputsFieldNumber = 2,
+    kCommonFieldNumber = 1,
+    kAdvancedExtensionFieldNumber = 10,
+    kOpFieldNumber = 3,
+  };
+  // repeated .substrait.Rel inputs = 2;
+  int inputs_size() const;
+  private:
+  int _internal_inputs_size() const;
+  public:
+  void clear_inputs();
+  ::substrait::Rel* mutable_inputs(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >*
+      mutable_inputs();
+  private:
+  const ::substrait::Rel& _internal_inputs(int index) const;
+  ::substrait::Rel* _internal_add_inputs();
+  public:
+  const ::substrait::Rel& inputs(int index) const;
+  ::substrait::Rel* add_inputs();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >&
+      inputs() const;
+
+  // .substrait.RelCommon common = 1;
+  bool has_common() const;
+  private:
+  bool _internal_has_common() const;
+  public:
+  void clear_common();
+  const ::substrait::RelCommon& common() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon* release_common();
+  ::substrait::RelCommon* mutable_common();
+  void set_allocated_common(::substrait::RelCommon* common);
+  private:
+  const ::substrait::RelCommon& _internal_common() const;
+  ::substrait::RelCommon* _internal_mutable_common();
+  public:
+  void unsafe_arena_set_allocated_common(
+      ::substrait::RelCommon* common);
+  ::substrait::RelCommon* unsafe_arena_release_common();
+
+  // .substrait.extensions.AdvancedExtension advanced_extension = 10;
+  bool has_advanced_extension() const;
+  private:
+  bool _internal_has_advanced_extension() const;
+  public:
+  void clear_advanced_extension();
+  const ::substrait::extensions::AdvancedExtension& advanced_extension() const;
+  PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension();
+  ::substrait::extensions::AdvancedExtension* mutable_advanced_extension();
+  void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension);
+  private:
+  const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const;
+  ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension();
+  public:
+  void unsafe_arena_set_allocated_advanced_extension(
+      ::substrait::extensions::AdvancedExtension* advanced_extension);
+  ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension();
+
+  // .substrait.SetRel.SetOp op = 3;
+  void clear_op();
+  ::substrait::SetRel_SetOp op() const;
+  void set_op(::substrait::SetRel_SetOp value);
+  private:
+  ::substrait::SetRel_SetOp _internal_op() const;
+  void _internal_set_op(::substrait::SetRel_SetOp value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.SetRel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel > inputs_;
+  ::substrait::RelCommon* common_;
+  ::substrait::extensions::AdvancedExtension* advanced_extension_;
+  int op_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ExtensionSingleRel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ExtensionSingleRel) */ {
+ public:
+  inline ExtensionSingleRel() : ExtensionSingleRel(nullptr) {}
+  ~ExtensionSingleRel() override;
+  explicit constexpr ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ExtensionSingleRel(const ExtensionSingleRel& from);
+  ExtensionSingleRel(ExtensionSingleRel&& from) noexcept
+    : ExtensionSingleRel() {
+    *this = ::std::move(from);
+  }
+
+  inline ExtensionSingleRel& operator=(const ExtensionSingleRel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ExtensionSingleRel& operator=(ExtensionSingleRel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ExtensionSingleRel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ExtensionSingleRel* internal_default_instance() {
+    return reinterpret_cast<const ExtensionSingleRel*>(
+               &_ExtensionSingleRel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    21;
+
+  friend void swap(ExtensionSingleRel& a, ExtensionSingleRel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ExtensionSingleRel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ExtensionSingleRel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ExtensionSingleRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ExtensionSingleRel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ExtensionSingleRel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ExtensionSingleRel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ExtensionSingleRel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ExtensionSingleRel";
+  }
+  protected:
+  explicit ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCommonFieldNumber = 1,
+    kInputFieldNumber = 2,
+    kDetailFieldNumber = 3,
+  };
+  // .substrait.RelCommon common = 1;
+  bool has_common() const;
+  private:
+  bool _internal_has_common() const;
+  public:
+  void clear_common();
+  const ::substrait::RelCommon& common() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon* release_common();
+  ::substrait::RelCommon* mutable_common();
+  void set_allocated_common(::substrait::RelCommon* common);
+  private:
+  const ::substrait::RelCommon& _internal_common() const;
+  ::substrait::RelCommon* _internal_mutable_common();
+  public:
+  void unsafe_arena_set_allocated_common(
+      ::substrait::RelCommon* common);
+  ::substrait::RelCommon* unsafe_arena_release_common();
+
+  // .substrait.Rel input = 2;
+  bool has_input() const;
+  private:
+  bool _internal_has_input() const;
+  public:
+  void clear_input();
+  const ::substrait::Rel& input() const;
+  PROTOBUF_NODISCARD ::substrait::Rel* release_input();
+  ::substrait::Rel* mutable_input();
+  void set_allocated_input(::substrait::Rel* input);
+  private:
+  const ::substrait::Rel& _internal_input() const;
+  ::substrait::Rel* _internal_mutable_input();
+  public:
+  void unsafe_arena_set_allocated_input(
+      ::substrait::Rel* input);
+  ::substrait::Rel* unsafe_arena_release_input();
+
+  // .google.protobuf.Any detail = 3;
+  bool has_detail() const;
+  private:
+  bool _internal_has_detail() const;
+  public:
+  void clear_detail();
+  const ::PROTOBUF_NAMESPACE_ID::Any& detail() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_detail();
+  ::PROTOBUF_NAMESPACE_ID::Any* mutable_detail();
+  void set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const;
+  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail();
+  public:
+  void unsafe_arena_set_allocated_detail(
+      ::PROTOBUF_NAMESPACE_ID::Any* detail);
+  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail();
+
+  // @@protoc_insertion_point(class_scope:substrait.ExtensionSingleRel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::RelCommon* common_;
+  ::substrait::Rel* input_;
+  ::PROTOBUF_NAMESPACE_ID::Any* detail_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ExtensionLeafRel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ExtensionLeafRel) */ {
+ public:
+  inline ExtensionLeafRel() : ExtensionLeafRel(nullptr) {}
+  ~ExtensionLeafRel() override;
+  explicit constexpr ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ExtensionLeafRel(const ExtensionLeafRel& from);
+  ExtensionLeafRel(ExtensionLeafRel&& from) noexcept
+    : ExtensionLeafRel() {
+    *this = ::std::move(from);
+  }
+
+  inline ExtensionLeafRel& operator=(const ExtensionLeafRel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ExtensionLeafRel& operator=(ExtensionLeafRel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ExtensionLeafRel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ExtensionLeafRel* internal_default_instance() {
+    return reinterpret_cast<const ExtensionLeafRel*>(
+               &_ExtensionLeafRel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    22;
+
+  friend void swap(ExtensionLeafRel& a, ExtensionLeafRel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ExtensionLeafRel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ExtensionLeafRel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ExtensionLeafRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ExtensionLeafRel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ExtensionLeafRel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ExtensionLeafRel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ExtensionLeafRel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ExtensionLeafRel";
+  }
+  protected:
+  explicit ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCommonFieldNumber = 1,
+    kDetailFieldNumber = 2,
+  };
+  // .substrait.RelCommon common = 1;
+  bool has_common() const;
+  private:
+  bool _internal_has_common() const;
+  public:
+  void clear_common();
+  const ::substrait::RelCommon& common() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon* release_common();
+  ::substrait::RelCommon* mutable_common();
+  void set_allocated_common(::substrait::RelCommon* common);
+  private:
+  const ::substrait::RelCommon& _internal_common() const;
+  ::substrait::RelCommon* _internal_mutable_common();
+  public:
+  void unsafe_arena_set_allocated_common(
+      ::substrait::RelCommon* common);
+  ::substrait::RelCommon* unsafe_arena_release_common();
+
+  // .google.protobuf.Any detail = 2;
+  bool has_detail() const;
+  private:
+  bool _internal_has_detail() const;
+  public:
+  void clear_detail();
+  const ::PROTOBUF_NAMESPACE_ID::Any& detail() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_detail();
+  ::PROTOBUF_NAMESPACE_ID::Any* mutable_detail();
+  void set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const;
+  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail();
+  public:
+  void unsafe_arena_set_allocated_detail(
+      ::PROTOBUF_NAMESPACE_ID::Any* detail);
+  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail();
+
+  // @@protoc_insertion_point(class_scope:substrait.ExtensionLeafRel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::RelCommon* common_;
+  ::PROTOBUF_NAMESPACE_ID::Any* detail_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ExtensionMultiRel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ExtensionMultiRel) */ {
+ public:
+  inline ExtensionMultiRel() : ExtensionMultiRel(nullptr) {}
+  ~ExtensionMultiRel() override;
+  explicit constexpr ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ExtensionMultiRel(const ExtensionMultiRel& from);
+  ExtensionMultiRel(ExtensionMultiRel&& from) noexcept
+    : ExtensionMultiRel() {
+    *this = ::std::move(from);
+  }
+
+  inline ExtensionMultiRel& operator=(const ExtensionMultiRel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ExtensionMultiRel& operator=(ExtensionMultiRel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ExtensionMultiRel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ExtensionMultiRel* internal_default_instance() {
+    return reinterpret_cast<const ExtensionMultiRel*>(
+               &_ExtensionMultiRel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    23;
+
+  friend void swap(ExtensionMultiRel& a, ExtensionMultiRel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ExtensionMultiRel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ExtensionMultiRel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ExtensionMultiRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ExtensionMultiRel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ExtensionMultiRel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ExtensionMultiRel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ExtensionMultiRel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.ExtensionMultiRel";
+  }
+  protected:
+  explicit ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kInputsFieldNumber = 2,
+    kCommonFieldNumber = 1,
+    kDetailFieldNumber = 3,
+  };
+  // repeated .substrait.Rel inputs = 2;
+  int inputs_size() const;
+  private:
+  int _internal_inputs_size() const;
+  public:
+  void clear_inputs();
+  ::substrait::Rel* mutable_inputs(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >*
+      mutable_inputs();
+  private:
+  const ::substrait::Rel& _internal_inputs(int index) const;
+  ::substrait::Rel* _internal_add_inputs();
+  public:
+  const ::substrait::Rel& inputs(int index) const;
+  ::substrait::Rel* add_inputs();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >&
+      inputs() const;
+
+  // .substrait.RelCommon common = 1;
+  bool has_common() const;
+  private:
+  bool _internal_has_common() const;
+  public:
+  void clear_common();
+  const ::substrait::RelCommon& common() const;
+  PROTOBUF_NODISCARD ::substrait::RelCommon* release_common();
+  ::substrait::RelCommon* mutable_common();
+  void set_allocated_common(::substrait::RelCommon* common);
+  private:
+  const ::substrait::RelCommon& _internal_common() const;
+  ::substrait::RelCommon* _internal_mutable_common();
+  public:
+  void unsafe_arena_set_allocated_common(
+      ::substrait::RelCommon* common);
+  ::substrait::RelCommon* unsafe_arena_release_common();
+
+  // .google.protobuf.Any detail = 3;
+  bool has_detail() const;
+  private:
+  bool _internal_has_detail() const;
+  public:
+  void clear_detail();
+  const ::PROTOBUF_NAMESPACE_ID::Any& detail() const;
+  PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_detail();
+  ::PROTOBUF_NAMESPACE_ID::Any* mutable_detail();
+  void set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail);
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const;
+  ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail();
+  public:
+  void unsafe_arena_set_allocated_detail(
+      ::PROTOBUF_NAMESPACE_ID::Any* detail);
+  ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail();
+
+  // @@protoc_insertion_point(class_scope:substrait.ExtensionMultiRel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel > inputs_;
+  ::substrait::RelCommon* common_;
+  ::PROTOBUF_NAMESPACE_ID::Any* detail_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RelRoot final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelRoot) */ {
+ public:
+  inline RelRoot() : RelRoot(nullptr) {}
+  ~RelRoot() override;
+  explicit constexpr RelRoot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RelRoot(const RelRoot& from);
+  RelRoot(RelRoot&& from) noexcept
+    : RelRoot() {
+    *this = ::std::move(from);
+  }
+
+  inline RelRoot& operator=(const RelRoot& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RelRoot& operator=(RelRoot&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RelRoot& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RelRoot* internal_default_instance() {
+    return reinterpret_cast<const RelRoot*>(
+               &_RelRoot_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    24;
+
+  friend void swap(RelRoot& a, RelRoot& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RelRoot* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RelRoot* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  RelRoot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<RelRoot>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RelRoot& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const RelRoot& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RelRoot* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.RelRoot";
+  }
+  protected:
+  explicit RelRoot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNamesFieldNumber = 2,
+    kInputFieldNumber = 1,
+  };
+  // repeated string names = 2;
+  int names_size() const;
+  private:
+  int _internal_names_size() const;
+  public:
+  void clear_names();
+  const std::string& names(int index) const;
+  std::string* mutable_names(int index);
+  void set_names(int index, const std::string& value);
+  void set_names(int index, std::string&& value);
+  void set_names(int index, const char* value);
+  void set_names(int index, const char* value, size_t size);
+  std::string* add_names();
+  void add_names(const std::string& value);
+  void add_names(std::string&& value);
+  void add_names(const char* value);
+  void add_names(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& names() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_names();
+  private:
+  const std::string& _internal_names(int index) const;
+  std::string* _internal_add_names();
+  public:
+
+  // .substrait.Rel input = 1;
+  bool has_input() const;
+  private:
+  bool _internal_has_input() const;
+  public:
+  void clear_input();
+  const ::substrait::Rel& input() const;
+  PROTOBUF_NODISCARD ::substrait::Rel* release_input();
+  ::substrait::Rel* mutable_input();
+  void set_allocated_input(::substrait::Rel* input);
+  private:
+  const ::substrait::Rel& _internal_input() const;
+  ::substrait::Rel* _internal_mutable_input();
+  public:
+  void unsafe_arena_set_allocated_input(
+      ::substrait::Rel* input);
+  ::substrait::Rel* unsafe_arena_release_input();
+
+  // @@protoc_insertion_point(class_scope:substrait.RelRoot)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> names_;
+  ::substrait::Rel* input_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Rel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Rel) */ {
+ public:
+  inline Rel() : Rel(nullptr) {}
+  ~Rel() override;
+  explicit constexpr Rel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Rel(const Rel& from);
+  Rel(Rel&& from) noexcept
+    : Rel() {
+    *this = ::std::move(from);
+  }
+
+  inline Rel& operator=(const Rel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Rel& operator=(Rel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Rel& default_instance() {
+    return *internal_default_instance();
+  }
+  enum RelTypeCase {
+    kRead = 1,
+    kFilter = 2,
+    kFetch = 3,
+    kAggregate = 4,
+    kSort = 5,
+    kJoin = 6,
+    kProject = 7,
+    kSet = 8,
+    kExtensionSingle = 9,
+    kExtensionMulti = 10,
+    kExtensionLeaf = 11,
+    REL_TYPE_NOT_SET = 0,
+  };
+
+  static inline const Rel* internal_default_instance() {
+    return reinterpret_cast<const Rel*>(
+               &_Rel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    25;
+
+  friend void swap(Rel& a, Rel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Rel* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Rel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Rel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Rel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Rel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Rel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Rel* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Rel";
+  }
+  protected:
+  explicit Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kReadFieldNumber = 1,
+    kFilterFieldNumber = 2,
+    kFetchFieldNumber = 3,
+    kAggregateFieldNumber = 4,
+    kSortFieldNumber = 5,
+    kJoinFieldNumber = 6,
+    kProjectFieldNumber = 7,
+    kSetFieldNumber = 8,
+    kExtensionSingleFieldNumber = 9,
+    kExtensionMultiFieldNumber = 10,
+    kExtensionLeafFieldNumber = 11,
+  };
+  // .substrait.ReadRel read = 1;
+  bool has_read() const;
+  private:
+  bool _internal_has_read() const;
+  public:
+  void clear_read();
+  const ::substrait::ReadRel& read() const;
+  PROTOBUF_NODISCARD ::substrait::ReadRel* release_read();
+  ::substrait::ReadRel* mutable_read();
+  void set_allocated_read(::substrait::ReadRel* read);
+  private:
+  const ::substrait::ReadRel& _internal_read() const;
+  ::substrait::ReadRel* _internal_mutable_read();
+  public:
+  void unsafe_arena_set_allocated_read(
+      ::substrait::ReadRel* read);
+  ::substrait::ReadRel* unsafe_arena_release_read();
+
+  // .substrait.FilterRel filter = 2;
+  bool has_filter() const;
+  private:
+  bool _internal_has_filter() const;
+  public:
+  void clear_filter();
+  const ::substrait::FilterRel& filter() const;
+  PROTOBUF_NODISCARD ::substrait::FilterRel* release_filter();
+  ::substrait::FilterRel* mutable_filter();
+  void set_allocated_filter(::substrait::FilterRel* filter);
+  private:
+  const ::substrait::FilterRel& _internal_filter() const;
+  ::substrait::FilterRel* _internal_mutable_filter();
+  public:
+  void unsafe_arena_set_allocated_filter(
+      ::substrait::FilterRel* filter);
+  ::substrait::FilterRel* unsafe_arena_release_filter();
+
+  // .substrait.FetchRel fetch = 3;
+  bool has_fetch() const;
+  private:
+  bool _internal_has_fetch() const;
+  public:
+  void clear_fetch();
+  const ::substrait::FetchRel& fetch() const;
+  PROTOBUF_NODISCARD ::substrait::FetchRel* release_fetch();
+  ::substrait::FetchRel* mutable_fetch();
+  void set_allocated_fetch(::substrait::FetchRel* fetch);
+  private:
+  const ::substrait::FetchRel& _internal_fetch() const;
+  ::substrait::FetchRel* _internal_mutable_fetch();
+  public:
+  void unsafe_arena_set_allocated_fetch(
+      ::substrait::FetchRel* fetch);
+  ::substrait::FetchRel* unsafe_arena_release_fetch();
+
+  // .substrait.AggregateRel aggregate = 4;
+  bool has_aggregate() const;
+  private:
+  bool _internal_has_aggregate() const;
+  public:
+  void clear_aggregate();
+  const ::substrait::AggregateRel& aggregate() const;
+  PROTOBUF_NODISCARD ::substrait::AggregateRel* release_aggregate();
+  ::substrait::AggregateRel* mutable_aggregate();
+  void set_allocated_aggregate(::substrait::AggregateRel* aggregate);
+  private:
+  const ::substrait::AggregateRel& _internal_aggregate() const;
+  ::substrait::AggregateRel* _internal_mutable_aggregate();
+  public:
+  void unsafe_arena_set_allocated_aggregate(
+      ::substrait::AggregateRel* aggregate);
+  ::substrait::AggregateRel* unsafe_arena_release_aggregate();
+
+  // .substrait.SortRel sort = 5;
+  bool has_sort() const;
+  private:
+  bool _internal_has_sort() const;
+  public:
+  void clear_sort();
+  const ::substrait::SortRel& sort() const;
+  PROTOBUF_NODISCARD ::substrait::SortRel* release_sort();
+  ::substrait::SortRel* mutable_sort();
+  void set_allocated_sort(::substrait::SortRel* sort);
+  private:
+  const ::substrait::SortRel& _internal_sort() const;
+  ::substrait::SortRel* _internal_mutable_sort();
+  public:
+  void unsafe_arena_set_allocated_sort(
+      ::substrait::SortRel* sort);
+  ::substrait::SortRel* unsafe_arena_release_sort();
+
+  // .substrait.JoinRel join = 6;
+  bool has_join() const;
+  private:
+  bool _internal_has_join() const;
+  public:
+  void clear_join();
+  const ::substrait::JoinRel& join() const;
+  PROTOBUF_NODISCARD ::substrait::JoinRel* release_join();
+  ::substrait::JoinRel* mutable_join();
+  void set_allocated_join(::substrait::JoinRel* join);
+  private:
+  const ::substrait::JoinRel& _internal_join() const;
+  ::substrait::JoinRel* _internal_mutable_join();
+  public:
+  void unsafe_arena_set_allocated_join(
+      ::substrait::JoinRel* join);
+  ::substrait::JoinRel* unsafe_arena_release_join();
+
+  // .substrait.ProjectRel project = 7;
+  bool has_project() const;
+  private:
+  bool _internal_has_project() const;
+  public:
+  void clear_project();
+  const ::substrait::ProjectRel& project() const;
+  PROTOBUF_NODISCARD ::substrait::ProjectRel* release_project();
+  ::substrait::ProjectRel* mutable_project();
+  void set_allocated_project(::substrait::ProjectRel* project);
+  private:
+  const ::substrait::ProjectRel& _internal_project() const;
+  ::substrait::ProjectRel* _internal_mutable_project();
+  public:
+  void unsafe_arena_set_allocated_project(
+      ::substrait::ProjectRel* project);
+  ::substrait::ProjectRel* unsafe_arena_release_project();
+
+  // .substrait.SetRel set = 8;
+  bool has_set() const;
+  private:
+  bool _internal_has_set() const;
+  public:
+  void clear_set();
+  const ::substrait::SetRel& set() const;
+  PROTOBUF_NODISCARD ::substrait::SetRel* release_set();
+  ::substrait::SetRel* mutable_set();
+  void set_allocated_set(::substrait::SetRel* set);
+  private:
+  const ::substrait::SetRel& _internal_set() const;
+  ::substrait::SetRel* _internal_mutable_set();
+  public:
+  void unsafe_arena_set_allocated_set(
+      ::substrait::SetRel* set);
+  ::substrait::SetRel* unsafe_arena_release_set();
+
+  // .substrait.ExtensionSingleRel extension_single = 9;
+  bool has_extension_single() const;
+  private:
+  bool _internal_has_extension_single() const;
+  public:
+  void clear_extension_single();
+  const ::substrait::ExtensionSingleRel& extension_single() const;
+  PROTOBUF_NODISCARD ::substrait::ExtensionSingleRel* release_extension_single();
+  ::substrait::ExtensionSingleRel* mutable_extension_single();
+  void set_allocated_extension_single(::substrait::ExtensionSingleRel* extension_single);
+  private:
+  const ::substrait::ExtensionSingleRel& _internal_extension_single() const;
+  ::substrait::ExtensionSingleRel* _internal_mutable_extension_single();
+  public:
+  void unsafe_arena_set_allocated_extension_single(
+      ::substrait::ExtensionSingleRel* extension_single);
+  ::substrait::ExtensionSingleRel* unsafe_arena_release_extension_single();
+
+  // .substrait.ExtensionMultiRel extension_multi = 10;
+  bool has_extension_multi() const;
+  private:
+  bool _internal_has_extension_multi() const;
+  public:
+  void clear_extension_multi();
+  const ::substrait::ExtensionMultiRel& extension_multi() const;
+  PROTOBUF_NODISCARD ::substrait::ExtensionMultiRel* release_extension_multi();
+  ::substrait::ExtensionMultiRel* mutable_extension_multi();
+  void set_allocated_extension_multi(::substrait::ExtensionMultiRel* extension_multi);
+  private:
+  const ::substrait::ExtensionMultiRel& _internal_extension_multi() const;
+  ::substrait::ExtensionMultiRel* _internal_mutable_extension_multi();
+  public:
+  void unsafe_arena_set_allocated_extension_multi(
+      ::substrait::ExtensionMultiRel* extension_multi);
+  ::substrait::ExtensionMultiRel* unsafe_arena_release_extension_multi();
+
+  // .substrait.ExtensionLeafRel extension_leaf = 11;
+  bool has_extension_leaf() const;
+  private:
+  bool _internal_has_extension_leaf() const;
+  public:
+  void clear_extension_leaf();
+  const ::substrait::ExtensionLeafRel& extension_leaf() const;
+  PROTOBUF_NODISCARD ::substrait::ExtensionLeafRel* release_extension_leaf();
+  ::substrait::ExtensionLeafRel* mutable_extension_leaf();
+  void set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_leaf);
+  private:
+  const ::substrait::ExtensionLeafRel& _internal_extension_leaf() const;
+  ::substrait::ExtensionLeafRel* _internal_mutable_extension_leaf();
+  public:
+  void unsafe_arena_set_allocated_extension_leaf(
+      ::substrait::ExtensionLeafRel* extension_leaf);
+  ::substrait::ExtensionLeafRel* unsafe_arena_release_extension_leaf();
+
+  void clear_rel_type();
+  RelTypeCase rel_type_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.Rel)
+ private:
+  class _Internal;
+  void set_has_read();
+  void set_has_filter();
+  void set_has_fetch();
+  void set_has_aggregate();
+  void set_has_sort();
+  void set_has_join();
+  void set_has_project();
+  void set_has_set();
+  void set_has_extension_single();
+  void set_has_extension_multi();
+  void set_has_extension_leaf();
+
+  inline bool has_rel_type() const;
+  inline void clear_has_rel_type();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union RelTypeUnion {
+    constexpr RelTypeUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::ReadRel* read_;
+    ::substrait::FilterRel* filter_;
+    ::substrait::FetchRel* fetch_;
+    ::substrait::AggregateRel* aggregate_;
+    ::substrait::SortRel* sort_;
+    ::substrait::JoinRel* join_;
+    ::substrait::ProjectRel* project_;
+    ::substrait::SetRel* set_;
+    ::substrait::ExtensionSingleRel* extension_single_;
+    ::substrait::ExtensionMultiRel* extension_multi_;
+    ::substrait::ExtensionLeafRel* extension_leaf_;
+  } rel_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2frelations_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// RelCommon_Direct
+
+// -------------------------------------------------------------------
+
+// RelCommon_Emit
+
+// repeated int32 output_mapping = 1;
+inline int RelCommon_Emit::_internal_output_mapping_size() const {
+  return output_mapping_.size();
+}
+inline int RelCommon_Emit::output_mapping_size() const {
+  return _internal_output_mapping_size();
+}
+inline void RelCommon_Emit::clear_output_mapping() {
+  output_mapping_.Clear();
+}
+inline int32_t RelCommon_Emit::_internal_output_mapping(int index) const {
+  return output_mapping_.Get(index);
+}
+inline int32_t RelCommon_Emit::output_mapping(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.RelCommon.Emit.output_mapping)
+  return _internal_output_mapping(index);
+}
+inline void RelCommon_Emit::set_output_mapping(int index, int32_t value) {
+  output_mapping_.Set(index, value);
+  // @@protoc_insertion_point(field_set:substrait.RelCommon.Emit.output_mapping)
+}
+inline void RelCommon_Emit::_internal_add_output_mapping(int32_t value) {
+  output_mapping_.Add(value);
+}
+inline void RelCommon_Emit::add_output_mapping(int32_t value) {
+  _internal_add_output_mapping(value);
+  // @@protoc_insertion_point(field_add:substrait.RelCommon.Emit.output_mapping)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+RelCommon_Emit::_internal_output_mapping() const {
+  return output_mapping_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+RelCommon_Emit::output_mapping() const {
+  // @@protoc_insertion_point(field_list:substrait.RelCommon.Emit.output_mapping)
+  return _internal_output_mapping();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+RelCommon_Emit::_internal_mutable_output_mapping() {
+  return &output_mapping_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+RelCommon_Emit::mutable_output_mapping() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.RelCommon.Emit.output_mapping)
+  return _internal_mutable_output_mapping();
+}
+
+// -------------------------------------------------------------------
+
+// RelCommon_Hint_Stats
+
+// double row_count = 1;
+inline void RelCommon_Hint_Stats::clear_row_count() {
+  row_count_ = 0;
+}
+inline double RelCommon_Hint_Stats::_internal_row_count() const {
+  return row_count_;
+}
+inline double RelCommon_Hint_Stats::row_count() const {
+  // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.Stats.row_count)
+  return _internal_row_count();
+}
+inline void RelCommon_Hint_Stats::_internal_set_row_count(double value) {
+  
+  row_count_ = value;
+}
+inline void RelCommon_Hint_Stats::set_row_count(double value) {
+  _internal_set_row_count(value);
+  // @@protoc_insertion_point(field_set:substrait.RelCommon.Hint.Stats.row_count)
+}
+
+// double record_size = 2;
+inline void RelCommon_Hint_Stats::clear_record_size() {
+  record_size_ = 0;
+}
+inline double RelCommon_Hint_Stats::_internal_record_size() const {
+  return record_size_;
+}
+inline double RelCommon_Hint_Stats::record_size() const {
+  // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.Stats.record_size)
+  return _internal_record_size();
+}
+inline void RelCommon_Hint_Stats::_internal_set_record_size(double value) {
+  
+  record_size_ = value;
+}
+inline void RelCommon_Hint_Stats::set_record_size(double value) {
+  _internal_set_record_size(value);
+  // @@protoc_insertion_point(field_set:substrait.RelCommon.Hint.Stats.record_size)
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool RelCommon_Hint_Stats::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool RelCommon_Hint_Stats::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_Stats::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_Stats::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.Stats.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void RelCommon_Hint_Stats::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.Stats.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.Stats.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.Stats.advanced_extension)
+  return _msg;
+}
+inline void RelCommon_Hint_Stats::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.Stats.advanced_extension)
+}
+
+// -------------------------------------------------------------------
+
+// RelCommon_Hint_RuntimeConstraint
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool RelCommon_Hint_RuntimeConstraint::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool RelCommon_Hint_RuntimeConstraint::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_RuntimeConstraint::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_RuntimeConstraint::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void RelCommon_Hint_RuntimeConstraint::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension)
+  return _msg;
+}
+inline void RelCommon_Hint_RuntimeConstraint::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension)
+}
+
+// -------------------------------------------------------------------
+
+// RelCommon_Hint
+
+// .substrait.RelCommon.Hint.Stats stats = 1;
+inline bool RelCommon_Hint::_internal_has_stats() const {
+  return this != internal_default_instance() && stats_ != nullptr;
+}
+inline bool RelCommon_Hint::has_stats() const {
+  return _internal_has_stats();
+}
+inline void RelCommon_Hint::clear_stats() {
+  if (GetArenaForAllocation() == nullptr && stats_ != nullptr) {
+    delete stats_;
+  }
+  stats_ = nullptr;
+}
+inline const ::substrait::RelCommon_Hint_Stats& RelCommon_Hint::_internal_stats() const {
+  const ::substrait::RelCommon_Hint_Stats* p = stats_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon_Hint_Stats&>(
+      ::substrait::_RelCommon_Hint_Stats_default_instance_);
+}
+inline const ::substrait::RelCommon_Hint_Stats& RelCommon_Hint::stats() const {
+  // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.stats)
+  return _internal_stats();
+}
+inline void RelCommon_Hint::unsafe_arena_set_allocated_stats(
+    ::substrait::RelCommon_Hint_Stats* stats) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(stats_);
+  }
+  stats_ = stats;
+  if (stats) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.stats)
+}
+inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::release_stats() {
+  
+  ::substrait::RelCommon_Hint_Stats* temp = stats_;
+  stats_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::unsafe_arena_release_stats() {
+  // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.stats)
+  
+  ::substrait::RelCommon_Hint_Stats* temp = stats_;
+  stats_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::_internal_mutable_stats() {
+  
+  if (stats_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint_Stats>(GetArenaForAllocation());
+    stats_ = p;
+  }
+  return stats_;
+}
+inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::mutable_stats() {
+  ::substrait::RelCommon_Hint_Stats* _msg = _internal_mutable_stats();
+  // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.stats)
+  return _msg;
+}
+inline void RelCommon_Hint::set_allocated_stats(::substrait::RelCommon_Hint_Stats* stats) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete stats_;
+  }
+  if (stats) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Hint_Stats>::GetOwningArena(stats);
+    if (message_arena != submessage_arena) {
+      stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, stats, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  stats_ = stats;
+  // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.stats)
+}
+
+// .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2;
+inline bool RelCommon_Hint::_internal_has_constraint() const {
+  return this != internal_default_instance() && constraint_ != nullptr;
+}
+inline bool RelCommon_Hint::has_constraint() const {
+  return _internal_has_constraint();
+}
+inline void RelCommon_Hint::clear_constraint() {
+  if (GetArenaForAllocation() == nullptr && constraint_ != nullptr) {
+    delete constraint_;
+  }
+  constraint_ = nullptr;
+}
+inline const ::substrait::RelCommon_Hint_RuntimeConstraint& RelCommon_Hint::_internal_constraint() const {
+  const ::substrait::RelCommon_Hint_RuntimeConstraint* p = constraint_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon_Hint_RuntimeConstraint&>(
+      ::substrait::_RelCommon_Hint_RuntimeConstraint_default_instance_);
+}
+inline const ::substrait::RelCommon_Hint_RuntimeConstraint& RelCommon_Hint::constraint() const {
+  // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.constraint)
+  return _internal_constraint();
+}
+inline void RelCommon_Hint::unsafe_arena_set_allocated_constraint(
+    ::substrait::RelCommon_Hint_RuntimeConstraint* constraint) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(constraint_);
+  }
+  constraint_ = constraint;
+  if (constraint) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.constraint)
+}
+inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::release_constraint() {
+  
+  ::substrait::RelCommon_Hint_RuntimeConstraint* temp = constraint_;
+  constraint_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::unsafe_arena_release_constraint() {
+  // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.constraint)
+  
+  ::substrait::RelCommon_Hint_RuntimeConstraint* temp = constraint_;
+  constraint_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::_internal_mutable_constraint() {
+  
+  if (constraint_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint_RuntimeConstraint>(GetArenaForAllocation());
+    constraint_ = p;
+  }
+  return constraint_;
+}
+inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::mutable_constraint() {
+  ::substrait::RelCommon_Hint_RuntimeConstraint* _msg = _internal_mutable_constraint();
+  // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.constraint)
+  return _msg;
+}
+inline void RelCommon_Hint::set_allocated_constraint(::substrait::RelCommon_Hint_RuntimeConstraint* constraint) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete constraint_;
+  }
+  if (constraint) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Hint_RuntimeConstraint>::GetOwningArena(constraint);
+    if (message_arena != submessage_arena) {
+      constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, constraint, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  constraint_ = constraint;
+  // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.constraint)
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool RelCommon_Hint::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool RelCommon_Hint::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void RelCommon_Hint::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.advanced_extension)
+  return _msg;
+}
+inline void RelCommon_Hint::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.advanced_extension)
+}
+
+// -------------------------------------------------------------------
+
+// RelCommon
+
+// .substrait.RelCommon.Direct direct = 1;
+inline bool RelCommon::_internal_has_direct() const {
+  return emit_kind_case() == kDirect;
+}
+inline bool RelCommon::has_direct() const {
+  return _internal_has_direct();
+}
+inline void RelCommon::set_has_direct() {
+  _oneof_case_[0] = kDirect;
+}
+inline void RelCommon::clear_direct() {
+  if (_internal_has_direct()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete emit_kind_.direct_;
+    }
+    clear_has_emit_kind();
+  }
+}
+inline ::substrait::RelCommon_Direct* RelCommon::release_direct() {
+  // @@protoc_insertion_point(field_release:substrait.RelCommon.direct)
+  if (_internal_has_direct()) {
+    clear_has_emit_kind();
+      ::substrait::RelCommon_Direct* temp = emit_kind_.direct_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    emit_kind_.direct_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::RelCommon_Direct& RelCommon::_internal_direct() const {
+  return _internal_has_direct()
+      ? *emit_kind_.direct_
+      : reinterpret_cast< ::substrait::RelCommon_Direct&>(::substrait::_RelCommon_Direct_default_instance_);
+}
+inline const ::substrait::RelCommon_Direct& RelCommon::direct() const {
+  // @@protoc_insertion_point(field_get:substrait.RelCommon.direct)
+  return _internal_direct();
+}
+inline ::substrait::RelCommon_Direct* RelCommon::unsafe_arena_release_direct() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.RelCommon.direct)
+  if (_internal_has_direct()) {
+    clear_has_emit_kind();
+    ::substrait::RelCommon_Direct* temp = emit_kind_.direct_;
+    emit_kind_.direct_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void RelCommon::unsafe_arena_set_allocated_direct(::substrait::RelCommon_Direct* direct) {
+  clear_emit_kind();
+  if (direct) {
+    set_has_direct();
+    emit_kind_.direct_ = direct;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.direct)
+}
+inline ::substrait::RelCommon_Direct* RelCommon::_internal_mutable_direct() {
+  if (!_internal_has_direct()) {
+    clear_emit_kind();
+    set_has_direct();
+    emit_kind_.direct_ = CreateMaybeMessage< ::substrait::RelCommon_Direct >(GetArenaForAllocation());
+  }
+  return emit_kind_.direct_;
+}
+inline ::substrait::RelCommon_Direct* RelCommon::mutable_direct() {
+  ::substrait::RelCommon_Direct* _msg = _internal_mutable_direct();
+  // @@protoc_insertion_point(field_mutable:substrait.RelCommon.direct)
+  return _msg;
+}
+
+// .substrait.RelCommon.Emit emit = 2;
+inline bool RelCommon::_internal_has_emit() const {
+  return emit_kind_case() == kEmit;
+}
+inline bool RelCommon::has_emit() const {
+  return _internal_has_emit();
+}
+inline void RelCommon::set_has_emit() {
+  _oneof_case_[0] = kEmit;
+}
+inline void RelCommon::clear_emit() {
+  if (_internal_has_emit()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete emit_kind_.emit_;
+    }
+    clear_has_emit_kind();
+  }
+}
+inline ::substrait::RelCommon_Emit* RelCommon::release_emit() {
+  // @@protoc_insertion_point(field_release:substrait.RelCommon.emit)
+  if (_internal_has_emit()) {
+    clear_has_emit_kind();
+      ::substrait::RelCommon_Emit* temp = emit_kind_.emit_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    emit_kind_.emit_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::RelCommon_Emit& RelCommon::_internal_emit() const {
+  return _internal_has_emit()
+      ? *emit_kind_.emit_
+      : reinterpret_cast< ::substrait::RelCommon_Emit&>(::substrait::_RelCommon_Emit_default_instance_);
+}
+inline const ::substrait::RelCommon_Emit& RelCommon::emit() const {
+  // @@protoc_insertion_point(field_get:substrait.RelCommon.emit)
+  return _internal_emit();
+}
+inline ::substrait::RelCommon_Emit* RelCommon::unsafe_arena_release_emit() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.RelCommon.emit)
+  if (_internal_has_emit()) {
+    clear_has_emit_kind();
+    ::substrait::RelCommon_Emit* temp = emit_kind_.emit_;
+    emit_kind_.emit_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void RelCommon::unsafe_arena_set_allocated_emit(::substrait::RelCommon_Emit* emit) {
+  clear_emit_kind();
+  if (emit) {
+    set_has_emit();
+    emit_kind_.emit_ = emit;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.emit)
+}
+inline ::substrait::RelCommon_Emit* RelCommon::_internal_mutable_emit() {
+  if (!_internal_has_emit()) {
+    clear_emit_kind();
+    set_has_emit();
+    emit_kind_.emit_ = CreateMaybeMessage< ::substrait::RelCommon_Emit >(GetArenaForAllocation());
+  }
+  return emit_kind_.emit_;
+}
+inline ::substrait::RelCommon_Emit* RelCommon::mutable_emit() {
+  ::substrait::RelCommon_Emit* _msg = _internal_mutable_emit();
+  // @@protoc_insertion_point(field_mutable:substrait.RelCommon.emit)
+  return _msg;
+}
+
+// .substrait.RelCommon.Hint hint = 3;
+inline bool RelCommon::_internal_has_hint() const {
+  return this != internal_default_instance() && hint_ != nullptr;
+}
+inline bool RelCommon::has_hint() const {
+  return _internal_has_hint();
+}
+inline void RelCommon::clear_hint() {
+  if (GetArenaForAllocation() == nullptr && hint_ != nullptr) {
+    delete hint_;
+  }
+  hint_ = nullptr;
+}
+inline const ::substrait::RelCommon_Hint& RelCommon::_internal_hint() const {
+  const ::substrait::RelCommon_Hint* p = hint_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon_Hint&>(
+      ::substrait::_RelCommon_Hint_default_instance_);
+}
+inline const ::substrait::RelCommon_Hint& RelCommon::hint() const {
+  // @@protoc_insertion_point(field_get:substrait.RelCommon.hint)
+  return _internal_hint();
+}
+inline void RelCommon::unsafe_arena_set_allocated_hint(
+    ::substrait::RelCommon_Hint* hint) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hint_);
+  }
+  hint_ = hint;
+  if (hint) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.hint)
+}
+inline ::substrait::RelCommon_Hint* RelCommon::release_hint() {
+  
+  ::substrait::RelCommon_Hint* temp = hint_;
+  hint_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon_Hint* RelCommon::unsafe_arena_release_hint() {
+  // @@protoc_insertion_point(field_release:substrait.RelCommon.hint)
+  
+  ::substrait::RelCommon_Hint* temp = hint_;
+  hint_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon_Hint* RelCommon::_internal_mutable_hint() {
+  
+  if (hint_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint>(GetArenaForAllocation());
+    hint_ = p;
+  }
+  return hint_;
+}
+inline ::substrait::RelCommon_Hint* RelCommon::mutable_hint() {
+  ::substrait::RelCommon_Hint* _msg = _internal_mutable_hint();
+  // @@protoc_insertion_point(field_mutable:substrait.RelCommon.hint)
+  return _msg;
+}
+inline void RelCommon::set_allocated_hint(::substrait::RelCommon_Hint* hint) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete hint_;
+  }
+  if (hint) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Hint>::GetOwningArena(hint);
+    if (message_arena != submessage_arena) {
+      hint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, hint, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  hint_ = hint;
+  // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.hint)
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 4;
+inline bool RelCommon::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool RelCommon::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& RelCommon::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& RelCommon::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.RelCommon.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void RelCommon::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.RelCommon.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* RelCommon::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.RelCommon.advanced_extension)
+  return _msg;
+}
+inline void RelCommon::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.advanced_extension)
+}
+
+inline bool RelCommon::has_emit_kind() const {
+  return emit_kind_case() != EMIT_KIND_NOT_SET;
+}
+inline void RelCommon::clear_has_emit_kind() {
+  _oneof_case_[0] = EMIT_KIND_NOT_SET;
+}
+inline RelCommon::EmitKindCase RelCommon::emit_kind_case() const {
+  return RelCommon::EmitKindCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ReadRel_NamedTable
+
+// repeated string names = 1;
+inline int ReadRel_NamedTable::_internal_names_size() const {
+  return names_.size();
+}
+inline int ReadRel_NamedTable::names_size() const {
+  return _internal_names_size();
+}
+inline void ReadRel_NamedTable::clear_names() {
+  names_.Clear();
+}
+inline std::string* ReadRel_NamedTable::add_names() {
+  std::string* _s = _internal_add_names();
+  // @@protoc_insertion_point(field_add_mutable:substrait.ReadRel.NamedTable.names)
+  return _s;
+}
+inline const std::string& ReadRel_NamedTable::_internal_names(int index) const {
+  return names_.Get(index);
+}
+inline const std::string& ReadRel_NamedTable::names(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.NamedTable.names)
+  return _internal_names(index);
+}
+inline std::string* ReadRel_NamedTable::mutable_names(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.NamedTable.names)
+  return names_.Mutable(index);
+}
+inline void ReadRel_NamedTable::set_names(int index, const std::string& value) {
+  names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.ReadRel.NamedTable.names)
+}
+inline void ReadRel_NamedTable::set_names(int index, std::string&& value) {
+  names_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.ReadRel.NamedTable.names)
+}
+inline void ReadRel_NamedTable::set_names(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.ReadRel.NamedTable.names)
+}
+inline void ReadRel_NamedTable::set_names(int index, const char* value, size_t size) {
+  names_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.ReadRel.NamedTable.names)
+}
+inline std::string* ReadRel_NamedTable::_internal_add_names() {
+  return names_.Add();
+}
+inline void ReadRel_NamedTable::add_names(const std::string& value) {
+  names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.ReadRel.NamedTable.names)
+}
+inline void ReadRel_NamedTable::add_names(std::string&& value) {
+  names_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.ReadRel.NamedTable.names)
+}
+inline void ReadRel_NamedTable::add_names(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.ReadRel.NamedTable.names)
+}
+inline void ReadRel_NamedTable::add_names(const char* value, size_t size) {
+  names_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.ReadRel.NamedTable.names)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ReadRel_NamedTable::names() const {
+  // @@protoc_insertion_point(field_list:substrait.ReadRel.NamedTable.names)
+  return names_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ReadRel_NamedTable::mutable_names() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.ReadRel.NamedTable.names)
+  return &names_;
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool ReadRel_NamedTable::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool ReadRel_NamedTable::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& ReadRel_NamedTable::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& ReadRel_NamedTable::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.NamedTable.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void ReadRel_NamedTable::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.NamedTable.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.NamedTable.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.NamedTable.advanced_extension)
+  return _msg;
+}
+inline void ReadRel_NamedTable::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.NamedTable.advanced_extension)
+}
+
+// -------------------------------------------------------------------
+
+// ReadRel_VirtualTable
+
+// repeated .substrait.Expression.Literal.Struct values = 1;
+inline int ReadRel_VirtualTable::_internal_values_size() const {
+  return values_.size();
+}
+inline int ReadRel_VirtualTable::values_size() const {
+  return _internal_values_size();
+}
+inline ::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::mutable_values(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.VirtualTable.values)
+  return values_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >*
+ReadRel_VirtualTable::mutable_values() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.ReadRel.VirtualTable.values)
+  return &values_;
+}
+inline const ::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::_internal_values(int index) const {
+  return values_.Get(index);
+}
+inline const ::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::values(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.VirtualTable.values)
+  return _internal_values(index);
+}
+inline ::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::_internal_add_values() {
+  return values_.Add();
+}
+inline ::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::add_values() {
+  ::substrait::Expression_Literal_Struct* _add = _internal_add_values();
+  // @@protoc_insertion_point(field_add:substrait.ReadRel.VirtualTable.values)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >&
+ReadRel_VirtualTable::values() const {
+  // @@protoc_insertion_point(field_list:substrait.ReadRel.VirtualTable.values)
+  return values_;
+}
+
+// -------------------------------------------------------------------
+
+// ReadRel_ExtensionTable
+
+// .google.protobuf.Any detail = 1;
+inline bool ReadRel_ExtensionTable::_internal_has_detail() const {
+  return this != internal_default_instance() && detail_ != nullptr;
+}
+inline bool ReadRel_ExtensionTable::has_detail() const {
+  return _internal_has_detail();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::_internal_detail() const {
+  const ::PROTOBUF_NAMESPACE_ID::Any* p = detail_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
+      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::detail() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.ExtensionTable.detail)
+  return _internal_detail();
+}
+inline void ReadRel_ExtensionTable::unsafe_arena_set_allocated_detail(
+    ::PROTOBUF_NAMESPACE_ID::Any* detail) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_);
+  }
+  detail_ = detail;
+  if (detail) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.ExtensionTable.detail)
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::release_detail() {
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_;
+  detail_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::unsafe_arena_release_detail() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.ExtensionTable.detail)
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_;
+  detail_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::_internal_mutable_detail() {
+  
+  if (detail_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
+    detail_ = p;
+  }
+  return detail_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::mutable_detail() {
+  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_detail();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.ExtensionTable.detail)
+  return _msg;
+}
+inline void ReadRel_ExtensionTable::set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_);
+  }
+  if (detail) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail));
+    if (message_arena != submessage_arena) {
+      detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, detail, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  detail_ = detail;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.ExtensionTable.detail)
+}
+
+// -------------------------------------------------------------------
+
+// ReadRel_LocalFiles_FileOrFiles
+
+// string uri_path = 1;
+inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_path() const {
+  return path_type_case() == kUriPath;
+}
+inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_path() const {
+  return _internal_has_uri_path();
+}
+inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_path() {
+  _oneof_case_[0] = kUriPath;
+}
+inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path() {
+  if (_internal_has_uri_path()) {
+    path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_path_type();
+  }
+}
+inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_path() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path)
+  return _internal_uri_path();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_uri_path()) {
+    clear_path_type();
+    set_has_uri_path();
+    path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path)
+}
+inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path() {
+  std::string* _s = _internal_mutable_uri_path();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path)
+  return _s;
+}
+inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path() const {
+  if (_internal_has_uri_path()) {
+    return path_type_.uri_path_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_path(const std::string& value) {
+  if (!_internal_has_uri_path()) {
+    clear_path_type();
+    set_has_uri_path();
+    path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path() {
+  if (!_internal_has_uri_path()) {
+    clear_path_type();
+    set_has_uri_path();
+    path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return path_type_.uri_path_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path)
+  if (_internal_has_uri_path()) {
+    clear_has_path_type();
+    return path_type_.uri_path_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path(std::string* uri_path) {
+  if (has_path_type()) {
+    clear_path_type();
+  }
+  if (uri_path != nullptr) {
+    set_has_uri_path();
+    path_type_.uri_path_.UnsafeSetDefault(uri_path);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(uri_path);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path)
+}
+
+// string uri_path_glob = 2;
+inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_path_glob() const {
+  return path_type_case() == kUriPathGlob;
+}
+inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_path_glob() const {
+  return _internal_has_uri_path_glob();
+}
+inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_path_glob() {
+  _oneof_case_[0] = kUriPathGlob;
+}
+inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path_glob() {
+  if (_internal_has_uri_path_glob()) {
+    path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_path_type();
+  }
+}
+inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_path_glob() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob)
+  return _internal_uri_path_glob();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path_glob(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_uri_path_glob()) {
+    clear_path_type();
+    set_has_uri_path_glob();
+    path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob)
+}
+inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path_glob() {
+  std::string* _s = _internal_mutable_uri_path_glob();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob)
+  return _s;
+}
+inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path_glob() const {
+  if (_internal_has_uri_path_glob()) {
+    return path_type_.uri_path_glob_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_path_glob(const std::string& value) {
+  if (!_internal_has_uri_path_glob()) {
+    clear_path_type();
+    set_has_uri_path_glob();
+    path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path_glob() {
+  if (!_internal_has_uri_path_glob()) {
+    clear_path_type();
+    set_has_uri_path_glob();
+    path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return path_type_.uri_path_glob_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path_glob() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob)
+  if (_internal_has_uri_path_glob()) {
+    clear_has_path_type();
+    return path_type_.uri_path_glob_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path_glob(std::string* uri_path_glob) {
+  if (has_path_type()) {
+    clear_path_type();
+  }
+  if (uri_path_glob != nullptr) {
+    set_has_uri_path_glob();
+    path_type_.uri_path_glob_.UnsafeSetDefault(uri_path_glob);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(uri_path_glob);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob)
+}
+
+// string uri_file = 3;
+inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_file() const {
+  return path_type_case() == kUriFile;
+}
+inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_file() const {
+  return _internal_has_uri_file();
+}
+inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_file() {
+  _oneof_case_[0] = kUriFile;
+}
+inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_file() {
+  if (_internal_has_uri_file()) {
+    path_type_.uri_file_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_path_type();
+  }
+}
+inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_file() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file)
+  return _internal_uri_file();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ReadRel_LocalFiles_FileOrFiles::set_uri_file(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_uri_file()) {
+    clear_path_type();
+    set_has_uri_file();
+    path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  path_type_.uri_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file)
+}
+inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_file() {
+  std::string* _s = _internal_mutable_uri_file();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file)
+  return _s;
+}
+inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_file() const {
+  if (_internal_has_uri_file()) {
+    return path_type_.uri_file_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_file(const std::string& value) {
+  if (!_internal_has_uri_file()) {
+    clear_path_type();
+    set_has_uri_file();
+    path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  path_type_.uri_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_file() {
+  if (!_internal_has_uri_file()) {
+    clear_path_type();
+    set_has_uri_file();
+    path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return path_type_.uri_file_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_file() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file)
+  if (_internal_has_uri_file()) {
+    clear_has_path_type();
+    return path_type_.uri_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_file(std::string* uri_file) {
+  if (has_path_type()) {
+    clear_path_type();
+  }
+  if (uri_file != nullptr) {
+    set_has_uri_file();
+    path_type_.uri_file_.UnsafeSetDefault(uri_file);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(uri_file);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file)
+}
+
+// string uri_folder = 4;
+inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_folder() const {
+  return path_type_case() == kUriFolder;
+}
+inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_folder() const {
+  return _internal_has_uri_folder();
+}
+inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_folder() {
+  _oneof_case_[0] = kUriFolder;
+}
+inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_folder() {
+  if (_internal_has_uri_folder()) {
+    path_type_.uri_folder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_path_type();
+  }
+}
+inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_folder() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder)
+  return _internal_uri_folder();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ReadRel_LocalFiles_FileOrFiles::set_uri_folder(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_uri_folder()) {
+    clear_path_type();
+    set_has_uri_folder();
+    path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  path_type_.uri_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder)
+}
+inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_folder() {
+  std::string* _s = _internal_mutable_uri_folder();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder)
+  return _s;
+}
+inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_folder() const {
+  if (_internal_has_uri_folder()) {
+    return path_type_.uri_folder_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_folder(const std::string& value) {
+  if (!_internal_has_uri_folder()) {
+    clear_path_type();
+    set_has_uri_folder();
+    path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  path_type_.uri_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_folder() {
+  if (!_internal_has_uri_folder()) {
+    clear_path_type();
+    set_has_uri_folder();
+    path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return path_type_.uri_folder_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_folder() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder)
+  if (_internal_has_uri_folder()) {
+    clear_has_path_type();
+    return path_type_.uri_folder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_folder(std::string* uri_folder) {
+  if (has_path_type()) {
+    clear_path_type();
+  }
+  if (uri_folder != nullptr) {
+    set_has_uri_folder();
+    path_type_.uri_folder_.UnsafeSetDefault(uri_folder);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(uri_folder);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder)
+}
+
+// .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5;
+inline void ReadRel_LocalFiles_FileOrFiles::clear_format() {
+  format_ = 0;
+}
+inline ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::_internal_format() const {
+  return static_cast< ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat >(format_);
+}
+inline ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::format() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.format)
+  return _internal_format();
+}
+inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_format(::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat value) {
+  
+  format_ = value;
+}
+inline void ReadRel_LocalFiles_FileOrFiles::set_format(::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat value) {
+  _internal_set_format(value);
+  // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.format)
+}
+
+// uint64 partition_index = 6;
+inline void ReadRel_LocalFiles_FileOrFiles::clear_partition_index() {
+  partition_index_ = uint64_t{0u};
+}
+inline uint64_t ReadRel_LocalFiles_FileOrFiles::_internal_partition_index() const {
+  return partition_index_;
+}
+inline uint64_t ReadRel_LocalFiles_FileOrFiles::partition_index() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.partition_index)
+  return _internal_partition_index();
+}
+inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_partition_index(uint64_t value) {
+  
+  partition_index_ = value;
+}
+inline void ReadRel_LocalFiles_FileOrFiles::set_partition_index(uint64_t value) {
+  _internal_set_partition_index(value);
+  // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.partition_index)
+}
+
+// uint64 start = 7;
+inline void ReadRel_LocalFiles_FileOrFiles::clear_start() {
+  start_ = uint64_t{0u};
+}
+inline uint64_t ReadRel_LocalFiles_FileOrFiles::_internal_start() const {
+  return start_;
+}
+inline uint64_t ReadRel_LocalFiles_FileOrFiles::start() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.start)
+  return _internal_start();
+}
+inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_start(uint64_t value) {
+  
+  start_ = value;
+}
+inline void ReadRel_LocalFiles_FileOrFiles::set_start(uint64_t value) {
+  _internal_set_start(value);
+  // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.start)
+}
+
+// uint64 length = 8;
+inline void ReadRel_LocalFiles_FileOrFiles::clear_length() {
+  length_ = uint64_t{0u};
+}
+inline uint64_t ReadRel_LocalFiles_FileOrFiles::_internal_length() const {
+  return length_;
+}
+inline uint64_t ReadRel_LocalFiles_FileOrFiles::length() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.length)
+  return _internal_length();
+}
+inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_length(uint64_t value) {
+  
+  length_ = value;
+}
+inline void ReadRel_LocalFiles_FileOrFiles::set_length(uint64_t value) {
+  _internal_set_length(value);
+  // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.length)
+}
+
+inline bool ReadRel_LocalFiles_FileOrFiles::has_path_type() const {
+  return path_type_case() != PATH_TYPE_NOT_SET;
+}
+inline void ReadRel_LocalFiles_FileOrFiles::clear_has_path_type() {
+  _oneof_case_[0] = PATH_TYPE_NOT_SET;
+}
+inline ReadRel_LocalFiles_FileOrFiles::PathTypeCase ReadRel_LocalFiles_FileOrFiles::path_type_case() const {
+  return ReadRel_LocalFiles_FileOrFiles::PathTypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ReadRel_LocalFiles
+
+// repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1;
+inline int ReadRel_LocalFiles::_internal_items_size() const {
+  return items_.size();
+}
+inline int ReadRel_LocalFiles::items_size() const {
+  return _internal_items_size();
+}
+inline void ReadRel_LocalFiles::clear_items() {
+  items_.Clear();
+}
+inline ::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::mutable_items(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.items)
+  return items_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >*
+ReadRel_LocalFiles::mutable_items() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.ReadRel.LocalFiles.items)
+  return &items_;
+}
+inline const ::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::_internal_items(int index) const {
+  return items_.Get(index);
+}
+inline const ::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::items(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.items)
+  return _internal_items(index);
+}
+inline ::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::_internal_add_items() {
+  return items_.Add();
+}
+inline ::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::add_items() {
+  ::substrait::ReadRel_LocalFiles_FileOrFiles* _add = _internal_add_items();
+  // @@protoc_insertion_point(field_add:substrait.ReadRel.LocalFiles.items)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >&
+ReadRel_LocalFiles::items() const {
+  // @@protoc_insertion_point(field_list:substrait.ReadRel.LocalFiles.items)
+  return items_;
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool ReadRel_LocalFiles::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool ReadRel_LocalFiles::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& ReadRel_LocalFiles::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& ReadRel_LocalFiles::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void ReadRel_LocalFiles::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.LocalFiles.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.advanced_extension)
+  return _msg;
+}
+inline void ReadRel_LocalFiles::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.advanced_extension)
+}
+
+// -------------------------------------------------------------------
+
+// ReadRel
+
+// .substrait.RelCommon common = 1;
+inline bool ReadRel::_internal_has_common() const {
+  return this != internal_default_instance() && common_ != nullptr;
+}
+inline bool ReadRel::has_common() const {
+  return _internal_has_common();
+}
+inline void ReadRel::clear_common() {
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+}
+inline const ::substrait::RelCommon& ReadRel::_internal_common() const {
+  const ::substrait::RelCommon* p = common_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon&>(
+      ::substrait::_RelCommon_default_instance_);
+}
+inline const ::substrait::RelCommon& ReadRel::common() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.common)
+  return _internal_common();
+}
+inline void ReadRel::unsafe_arena_set_allocated_common(
+    ::substrait::RelCommon* common) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_);
+  }
+  common_ = common;
+  if (common) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.common)
+}
+inline ::substrait::RelCommon* ReadRel::release_common() {
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon* ReadRel::unsafe_arena_release_common() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.common)
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon* ReadRel::_internal_mutable_common() {
+  
+  if (common_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation());
+    common_ = p;
+  }
+  return common_;
+}
+inline ::substrait::RelCommon* ReadRel::mutable_common() {
+  ::substrait::RelCommon* _msg = _internal_mutable_common();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.common)
+  return _msg;
+}
+inline void ReadRel::set_allocated_common(::substrait::RelCommon* common) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete common_;
+  }
+  if (common) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common);
+    if (message_arena != submessage_arena) {
+      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, common, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  common_ = common;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.common)
+}
+
+// .substrait.NamedStruct base_schema = 2;
+inline bool ReadRel::_internal_has_base_schema() const {
+  return this != internal_default_instance() && base_schema_ != nullptr;
+}
+inline bool ReadRel::has_base_schema() const {
+  return _internal_has_base_schema();
+}
+inline const ::substrait::NamedStruct& ReadRel::_internal_base_schema() const {
+  const ::substrait::NamedStruct* p = base_schema_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::NamedStruct&>(
+      ::substrait::_NamedStruct_default_instance_);
+}
+inline const ::substrait::NamedStruct& ReadRel::base_schema() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.base_schema)
+  return _internal_base_schema();
+}
+inline void ReadRel::unsafe_arena_set_allocated_base_schema(
+    ::substrait::NamedStruct* base_schema) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_);
+  }
+  base_schema_ = base_schema;
+  if (base_schema) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.base_schema)
+}
+inline ::substrait::NamedStruct* ReadRel::release_base_schema() {
+  
+  ::substrait::NamedStruct* temp = base_schema_;
+  base_schema_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::NamedStruct* ReadRel::unsafe_arena_release_base_schema() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.base_schema)
+  
+  ::substrait::NamedStruct* temp = base_schema_;
+  base_schema_ = nullptr;
+  return temp;
+}
+inline ::substrait::NamedStruct* ReadRel::_internal_mutable_base_schema() {
+  
+  if (base_schema_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::NamedStruct>(GetArenaForAllocation());
+    base_schema_ = p;
+  }
+  return base_schema_;
+}
+inline ::substrait::NamedStruct* ReadRel::mutable_base_schema() {
+  ::substrait::NamedStruct* _msg = _internal_mutable_base_schema();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.base_schema)
+  return _msg;
+}
+inline void ReadRel::set_allocated_base_schema(::substrait::NamedStruct* base_schema) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_);
+  }
+  if (base_schema) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema));
+    if (message_arena != submessage_arena) {
+      base_schema = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, base_schema, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  base_schema_ = base_schema;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.base_schema)
+}
+
+// .substrait.Expression filter = 3;
+inline bool ReadRel::_internal_has_filter() const {
+  return this != internal_default_instance() && filter_ != nullptr;
+}
+inline bool ReadRel::has_filter() const {
+  return _internal_has_filter();
+}
+inline const ::substrait::Expression& ReadRel::_internal_filter() const {
+  const ::substrait::Expression* p = filter_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& ReadRel::filter() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.filter)
+  return _internal_filter();
+}
+inline void ReadRel::unsafe_arena_set_allocated_filter(
+    ::substrait::Expression* filter) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_);
+  }
+  filter_ = filter;
+  if (filter) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.filter)
+}
+inline ::substrait::Expression* ReadRel::release_filter() {
+  
+  ::substrait::Expression* temp = filter_;
+  filter_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* ReadRel::unsafe_arena_release_filter() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.filter)
+  
+  ::substrait::Expression* temp = filter_;
+  filter_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* ReadRel::_internal_mutable_filter() {
+  
+  if (filter_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    filter_ = p;
+  }
+  return filter_;
+}
+inline ::substrait::Expression* ReadRel::mutable_filter() {
+  ::substrait::Expression* _msg = _internal_mutable_filter();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.filter)
+  return _msg;
+}
+inline void ReadRel::set_allocated_filter(::substrait::Expression* filter) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_);
+  }
+  if (filter) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter));
+    if (message_arena != submessage_arena) {
+      filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, filter, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  filter_ = filter;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.filter)
+}
+
+// .substrait.Expression.MaskExpression projection = 4;
+inline bool ReadRel::_internal_has_projection() const {
+  return this != internal_default_instance() && projection_ != nullptr;
+}
+inline bool ReadRel::has_projection() const {
+  return _internal_has_projection();
+}
+inline const ::substrait::Expression_MaskExpression& ReadRel::_internal_projection() const {
+  const ::substrait::Expression_MaskExpression* p = projection_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression_MaskExpression&>(
+      ::substrait::_Expression_MaskExpression_default_instance_);
+}
+inline const ::substrait::Expression_MaskExpression& ReadRel::projection() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.projection)
+  return _internal_projection();
+}
+inline void ReadRel::unsafe_arena_set_allocated_projection(
+    ::substrait::Expression_MaskExpression* projection) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_);
+  }
+  projection_ = projection;
+  if (projection) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.projection)
+}
+inline ::substrait::Expression_MaskExpression* ReadRel::release_projection() {
+  
+  ::substrait::Expression_MaskExpression* temp = projection_;
+  projection_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression_MaskExpression* ReadRel::unsafe_arena_release_projection() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.projection)
+  
+  ::substrait::Expression_MaskExpression* temp = projection_;
+  projection_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression_MaskExpression* ReadRel::_internal_mutable_projection() {
+  
+  if (projection_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression>(GetArenaForAllocation());
+    projection_ = p;
+  }
+  return projection_;
+}
+inline ::substrait::Expression_MaskExpression* ReadRel::mutable_projection() {
+  ::substrait::Expression_MaskExpression* _msg = _internal_mutable_projection();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.projection)
+  return _msg;
+}
+inline void ReadRel::set_allocated_projection(::substrait::Expression_MaskExpression* projection) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_);
+  }
+  if (projection) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection));
+    if (message_arena != submessage_arena) {
+      projection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, projection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  projection_ = projection;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.projection)
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool ReadRel::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool ReadRel::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& ReadRel::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& ReadRel::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void ReadRel::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* ReadRel::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* ReadRel::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* ReadRel::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* ReadRel::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.advanced_extension)
+  return _msg;
+}
+inline void ReadRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.advanced_extension)
+}
+
+// .substrait.ReadRel.VirtualTable virtual_table = 5;
+inline bool ReadRel::_internal_has_virtual_table() const {
+  return read_type_case() == kVirtualTable;
+}
+inline bool ReadRel::has_virtual_table() const {
+  return _internal_has_virtual_table();
+}
+inline void ReadRel::set_has_virtual_table() {
+  _oneof_case_[0] = kVirtualTable;
+}
+inline void ReadRel::clear_virtual_table() {
+  if (_internal_has_virtual_table()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete read_type_.virtual_table_;
+    }
+    clear_has_read_type();
+  }
+}
+inline ::substrait::ReadRel_VirtualTable* ReadRel::release_virtual_table() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.virtual_table)
+  if (_internal_has_virtual_table()) {
+    clear_has_read_type();
+      ::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    read_type_.virtual_table_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ReadRel_VirtualTable& ReadRel::_internal_virtual_table() const {
+  return _internal_has_virtual_table()
+      ? *read_type_.virtual_table_
+      : reinterpret_cast< ::substrait::ReadRel_VirtualTable&>(::substrait::_ReadRel_VirtualTable_default_instance_);
+}
+inline const ::substrait::ReadRel_VirtualTable& ReadRel::virtual_table() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.virtual_table)
+  return _internal_virtual_table();
+}
+inline ::substrait::ReadRel_VirtualTable* ReadRel::unsafe_arena_release_virtual_table() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ReadRel.virtual_table)
+  if (_internal_has_virtual_table()) {
+    clear_has_read_type();
+    ::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_;
+    read_type_.virtual_table_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ReadRel::unsafe_arena_set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* virtual_table) {
+  clear_read_type();
+  if (virtual_table) {
+    set_has_virtual_table();
+    read_type_.virtual_table_ = virtual_table;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.virtual_table)
+}
+inline ::substrait::ReadRel_VirtualTable* ReadRel::_internal_mutable_virtual_table() {
+  if (!_internal_has_virtual_table()) {
+    clear_read_type();
+    set_has_virtual_table();
+    read_type_.virtual_table_ = CreateMaybeMessage< ::substrait::ReadRel_VirtualTable >(GetArenaForAllocation());
+  }
+  return read_type_.virtual_table_;
+}
+inline ::substrait::ReadRel_VirtualTable* ReadRel::mutable_virtual_table() {
+  ::substrait::ReadRel_VirtualTable* _msg = _internal_mutable_virtual_table();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.virtual_table)
+  return _msg;
+}
+
+// .substrait.ReadRel.LocalFiles local_files = 6;
+inline bool ReadRel::_internal_has_local_files() const {
+  return read_type_case() == kLocalFiles;
+}
+inline bool ReadRel::has_local_files() const {
+  return _internal_has_local_files();
+}
+inline void ReadRel::set_has_local_files() {
+  _oneof_case_[0] = kLocalFiles;
+}
+inline void ReadRel::clear_local_files() {
+  if (_internal_has_local_files()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete read_type_.local_files_;
+    }
+    clear_has_read_type();
+  }
+}
+inline ::substrait::ReadRel_LocalFiles* ReadRel::release_local_files() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.local_files)
+  if (_internal_has_local_files()) {
+    clear_has_read_type();
+      ::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    read_type_.local_files_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ReadRel_LocalFiles& ReadRel::_internal_local_files() const {
+  return _internal_has_local_files()
+      ? *read_type_.local_files_
+      : reinterpret_cast< ::substrait::ReadRel_LocalFiles&>(::substrait::_ReadRel_LocalFiles_default_instance_);
+}
+inline const ::substrait::ReadRel_LocalFiles& ReadRel::local_files() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.local_files)
+  return _internal_local_files();
+}
+inline ::substrait::ReadRel_LocalFiles* ReadRel::unsafe_arena_release_local_files() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ReadRel.local_files)
+  if (_internal_has_local_files()) {
+    clear_has_read_type();
+    ::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_;
+    read_type_.local_files_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ReadRel::unsafe_arena_set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_files) {
+  clear_read_type();
+  if (local_files) {
+    set_has_local_files();
+    read_type_.local_files_ = local_files;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.local_files)
+}
+inline ::substrait::ReadRel_LocalFiles* ReadRel::_internal_mutable_local_files() {
+  if (!_internal_has_local_files()) {
+    clear_read_type();
+    set_has_local_files();
+    read_type_.local_files_ = CreateMaybeMessage< ::substrait::ReadRel_LocalFiles >(GetArenaForAllocation());
+  }
+  return read_type_.local_files_;
+}
+inline ::substrait::ReadRel_LocalFiles* ReadRel::mutable_local_files() {
+  ::substrait::ReadRel_LocalFiles* _msg = _internal_mutable_local_files();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.local_files)
+  return _msg;
+}
+
+// .substrait.ReadRel.NamedTable named_table = 7;
+inline bool ReadRel::_internal_has_named_table() const {
+  return read_type_case() == kNamedTable;
+}
+inline bool ReadRel::has_named_table() const {
+  return _internal_has_named_table();
+}
+inline void ReadRel::set_has_named_table() {
+  _oneof_case_[0] = kNamedTable;
+}
+inline void ReadRel::clear_named_table() {
+  if (_internal_has_named_table()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete read_type_.named_table_;
+    }
+    clear_has_read_type();
+  }
+}
+inline ::substrait::ReadRel_NamedTable* ReadRel::release_named_table() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.named_table)
+  if (_internal_has_named_table()) {
+    clear_has_read_type();
+      ::substrait::ReadRel_NamedTable* temp = read_type_.named_table_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    read_type_.named_table_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ReadRel_NamedTable& ReadRel::_internal_named_table() const {
+  return _internal_has_named_table()
+      ? *read_type_.named_table_
+      : reinterpret_cast< ::substrait::ReadRel_NamedTable&>(::substrait::_ReadRel_NamedTable_default_instance_);
+}
+inline const ::substrait::ReadRel_NamedTable& ReadRel::named_table() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.named_table)
+  return _internal_named_table();
+}
+inline ::substrait::ReadRel_NamedTable* ReadRel::unsafe_arena_release_named_table() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ReadRel.named_table)
+  if (_internal_has_named_table()) {
+    clear_has_read_type();
+    ::substrait::ReadRel_NamedTable* temp = read_type_.named_table_;
+    read_type_.named_table_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ReadRel::unsafe_arena_set_allocated_named_table(::substrait::ReadRel_NamedTable* named_table) {
+  clear_read_type();
+  if (named_table) {
+    set_has_named_table();
+    read_type_.named_table_ = named_table;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.named_table)
+}
+inline ::substrait::ReadRel_NamedTable* ReadRel::_internal_mutable_named_table() {
+  if (!_internal_has_named_table()) {
+    clear_read_type();
+    set_has_named_table();
+    read_type_.named_table_ = CreateMaybeMessage< ::substrait::ReadRel_NamedTable >(GetArenaForAllocation());
+  }
+  return read_type_.named_table_;
+}
+inline ::substrait::ReadRel_NamedTable* ReadRel::mutable_named_table() {
+  ::substrait::ReadRel_NamedTable* _msg = _internal_mutable_named_table();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.named_table)
+  return _msg;
+}
+
+// .substrait.ReadRel.ExtensionTable extension_table = 8;
+inline bool ReadRel::_internal_has_extension_table() const {
+  return read_type_case() == kExtensionTable;
+}
+inline bool ReadRel::has_extension_table() const {
+  return _internal_has_extension_table();
+}
+inline void ReadRel::set_has_extension_table() {
+  _oneof_case_[0] = kExtensionTable;
+}
+inline void ReadRel::clear_extension_table() {
+  if (_internal_has_extension_table()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete read_type_.extension_table_;
+    }
+    clear_has_read_type();
+  }
+}
+inline ::substrait::ReadRel_ExtensionTable* ReadRel::release_extension_table() {
+  // @@protoc_insertion_point(field_release:substrait.ReadRel.extension_table)
+  if (_internal_has_extension_table()) {
+    clear_has_read_type();
+      ::substrait::ReadRel_ExtensionTable* temp = read_type_.extension_table_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    read_type_.extension_table_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ReadRel_ExtensionTable& ReadRel::_internal_extension_table() const {
+  return _internal_has_extension_table()
+      ? *read_type_.extension_table_
+      : reinterpret_cast< ::substrait::ReadRel_ExtensionTable&>(::substrait::_ReadRel_ExtensionTable_default_instance_);
+}
+inline const ::substrait::ReadRel_ExtensionTable& ReadRel::extension_table() const {
+  // @@protoc_insertion_point(field_get:substrait.ReadRel.extension_table)
+  return _internal_extension_table();
+}
+inline ::substrait::ReadRel_ExtensionTable* ReadRel::unsafe_arena_release_extension_table() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ReadRel.extension_table)
+  if (_internal_has_extension_table()) {
+    clear_has_read_type();
+    ::substrait::ReadRel_ExtensionTable* temp = read_type_.extension_table_;
+    read_type_.extension_table_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ReadRel::unsafe_arena_set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* extension_table) {
+  clear_read_type();
+  if (extension_table) {
+    set_has_extension_table();
+    read_type_.extension_table_ = extension_table;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.extension_table)
+}
+inline ::substrait::ReadRel_ExtensionTable* ReadRel::_internal_mutable_extension_table() {
+  if (!_internal_has_extension_table()) {
+    clear_read_type();
+    set_has_extension_table();
+    read_type_.extension_table_ = CreateMaybeMessage< ::substrait::ReadRel_ExtensionTable >(GetArenaForAllocation());
+  }
+  return read_type_.extension_table_;
+}
+inline ::substrait::ReadRel_ExtensionTable* ReadRel::mutable_extension_table() {
+  ::substrait::ReadRel_ExtensionTable* _msg = _internal_mutable_extension_table();
+  // @@protoc_insertion_point(field_mutable:substrait.ReadRel.extension_table)
+  return _msg;
+}
+
+inline bool ReadRel::has_read_type() const {
+  return read_type_case() != READ_TYPE_NOT_SET;
+}
+inline void ReadRel::clear_has_read_type() {
+  _oneof_case_[0] = READ_TYPE_NOT_SET;
+}
+inline ReadRel::ReadTypeCase ReadRel::read_type_case() const {
+  return ReadRel::ReadTypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ProjectRel
+
+// .substrait.RelCommon common = 1;
+inline bool ProjectRel::_internal_has_common() const {
+  return this != internal_default_instance() && common_ != nullptr;
+}
+inline bool ProjectRel::has_common() const {
+  return _internal_has_common();
+}
+inline void ProjectRel::clear_common() {
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+}
+inline const ::substrait::RelCommon& ProjectRel::_internal_common() const {
+  const ::substrait::RelCommon* p = common_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon&>(
+      ::substrait::_RelCommon_default_instance_);
+}
+inline const ::substrait::RelCommon& ProjectRel::common() const {
+  // @@protoc_insertion_point(field_get:substrait.ProjectRel.common)
+  return _internal_common();
+}
+inline void ProjectRel::unsafe_arena_set_allocated_common(
+    ::substrait::RelCommon* common) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_);
+  }
+  common_ = common;
+  if (common) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ProjectRel.common)
+}
+inline ::substrait::RelCommon* ProjectRel::release_common() {
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon* ProjectRel::unsafe_arena_release_common() {
+  // @@protoc_insertion_point(field_release:substrait.ProjectRel.common)
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon* ProjectRel::_internal_mutable_common() {
+  
+  if (common_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation());
+    common_ = p;
+  }
+  return common_;
+}
+inline ::substrait::RelCommon* ProjectRel::mutable_common() {
+  ::substrait::RelCommon* _msg = _internal_mutable_common();
+  // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.common)
+  return _msg;
+}
+inline void ProjectRel::set_allocated_common(::substrait::RelCommon* common) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete common_;
+  }
+  if (common) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common);
+    if (message_arena != submessage_arena) {
+      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, common, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  common_ = common;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ProjectRel.common)
+}
+
+// .substrait.Rel input = 2;
+inline bool ProjectRel::_internal_has_input() const {
+  return this != internal_default_instance() && input_ != nullptr;
+}
+inline bool ProjectRel::has_input() const {
+  return _internal_has_input();
+}
+inline void ProjectRel::clear_input() {
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+}
+inline const ::substrait::Rel& ProjectRel::_internal_input() const {
+  const ::substrait::Rel* p = input_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Rel&>(
+      ::substrait::_Rel_default_instance_);
+}
+inline const ::substrait::Rel& ProjectRel::input() const {
+  // @@protoc_insertion_point(field_get:substrait.ProjectRel.input)
+  return _internal_input();
+}
+inline void ProjectRel::unsafe_arena_set_allocated_input(
+    ::substrait::Rel* input) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_);
+  }
+  input_ = input;
+  if (input) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ProjectRel.input)
+}
+inline ::substrait::Rel* ProjectRel::release_input() {
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Rel* ProjectRel::unsafe_arena_release_input() {
+  // @@protoc_insertion_point(field_release:substrait.ProjectRel.input)
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+  return temp;
+}
+inline ::substrait::Rel* ProjectRel::_internal_mutable_input() {
+  
+  if (input_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation());
+    input_ = p;
+  }
+  return input_;
+}
+inline ::substrait::Rel* ProjectRel::mutable_input() {
+  ::substrait::Rel* _msg = _internal_mutable_input();
+  // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.input)
+  return _msg;
+}
+inline void ProjectRel::set_allocated_input(::substrait::Rel* input) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete input_;
+  }
+  if (input) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input);
+    if (message_arena != submessage_arena) {
+      input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, input, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  input_ = input;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ProjectRel.input)
+}
+
+// repeated .substrait.Expression expressions = 3;
+inline int ProjectRel::_internal_expressions_size() const {
+  return expressions_.size();
+}
+inline int ProjectRel::expressions_size() const {
+  return _internal_expressions_size();
+}
+inline ::substrait::Expression* ProjectRel::mutable_expressions(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.expressions)
+  return expressions_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+ProjectRel::mutable_expressions() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.ProjectRel.expressions)
+  return &expressions_;
+}
+inline const ::substrait::Expression& ProjectRel::_internal_expressions(int index) const {
+  return expressions_.Get(index);
+}
+inline const ::substrait::Expression& ProjectRel::expressions(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.ProjectRel.expressions)
+  return _internal_expressions(index);
+}
+inline ::substrait::Expression* ProjectRel::_internal_add_expressions() {
+  return expressions_.Add();
+}
+inline ::substrait::Expression* ProjectRel::add_expressions() {
+  ::substrait::Expression* _add = _internal_add_expressions();
+  // @@protoc_insertion_point(field_add:substrait.ProjectRel.expressions)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+ProjectRel::expressions() const {
+  // @@protoc_insertion_point(field_list:substrait.ProjectRel.expressions)
+  return expressions_;
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool ProjectRel::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool ProjectRel::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& ProjectRel::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& ProjectRel::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.ProjectRel.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void ProjectRel::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ProjectRel.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* ProjectRel::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* ProjectRel::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.ProjectRel.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* ProjectRel::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* ProjectRel::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.advanced_extension)
+  return _msg;
+}
+inline void ProjectRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ProjectRel.advanced_extension)
+}
+
+// -------------------------------------------------------------------
+
+// JoinRel
+
+// .substrait.RelCommon common = 1;
+inline bool JoinRel::_internal_has_common() const {
+  return this != internal_default_instance() && common_ != nullptr;
+}
+inline bool JoinRel::has_common() const {
+  return _internal_has_common();
+}
+inline void JoinRel::clear_common() {
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+}
+inline const ::substrait::RelCommon& JoinRel::_internal_common() const {
+  const ::substrait::RelCommon* p = common_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon&>(
+      ::substrait::_RelCommon_default_instance_);
+}
+inline const ::substrait::RelCommon& JoinRel::common() const {
+  // @@protoc_insertion_point(field_get:substrait.JoinRel.common)
+  return _internal_common();
+}
+inline void JoinRel::unsafe_arena_set_allocated_common(
+    ::substrait::RelCommon* common) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_);
+  }
+  common_ = common;
+  if (common) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.common)
+}
+inline ::substrait::RelCommon* JoinRel::release_common() {
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon* JoinRel::unsafe_arena_release_common() {
+  // @@protoc_insertion_point(field_release:substrait.JoinRel.common)
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon* JoinRel::_internal_mutable_common() {
+  
+  if (common_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation());
+    common_ = p;
+  }
+  return common_;
+}
+inline ::substrait::RelCommon* JoinRel::mutable_common() {
+  ::substrait::RelCommon* _msg = _internal_mutable_common();
+  // @@protoc_insertion_point(field_mutable:substrait.JoinRel.common)
+  return _msg;
+}
+inline void JoinRel::set_allocated_common(::substrait::RelCommon* common) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete common_;
+  }
+  if (common) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common);
+    if (message_arena != submessage_arena) {
+      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, common, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  common_ = common;
+  // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.common)
+}
+
+// .substrait.Rel left = 2;
+inline bool JoinRel::_internal_has_left() const {
+  return this != internal_default_instance() && left_ != nullptr;
+}
+inline bool JoinRel::has_left() const {
+  return _internal_has_left();
+}
+inline void JoinRel::clear_left() {
+  if (GetArenaForAllocation() == nullptr && left_ != nullptr) {
+    delete left_;
+  }
+  left_ = nullptr;
+}
+inline const ::substrait::Rel& JoinRel::_internal_left() const {
+  const ::substrait::Rel* p = left_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Rel&>(
+      ::substrait::_Rel_default_instance_);
+}
+inline const ::substrait::Rel& JoinRel::left() const {
+  // @@protoc_insertion_point(field_get:substrait.JoinRel.left)
+  return _internal_left();
+}
+inline void JoinRel::unsafe_arena_set_allocated_left(
+    ::substrait::Rel* left) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(left_);
+  }
+  left_ = left;
+  if (left) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.left)
+}
+inline ::substrait::Rel* JoinRel::release_left() {
+  
+  ::substrait::Rel* temp = left_;
+  left_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Rel* JoinRel::unsafe_arena_release_left() {
+  // @@protoc_insertion_point(field_release:substrait.JoinRel.left)
+  
+  ::substrait::Rel* temp = left_;
+  left_ = nullptr;
+  return temp;
+}
+inline ::substrait::Rel* JoinRel::_internal_mutable_left() {
+  
+  if (left_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation());
+    left_ = p;
+  }
+  return left_;
+}
+inline ::substrait::Rel* JoinRel::mutable_left() {
+  ::substrait::Rel* _msg = _internal_mutable_left();
+  // @@protoc_insertion_point(field_mutable:substrait.JoinRel.left)
+  return _msg;
+}
+inline void JoinRel::set_allocated_left(::substrait::Rel* left) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete left_;
+  }
+  if (left) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(left);
+    if (message_arena != submessage_arena) {
+      left = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, left, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  left_ = left;
+  // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.left)
+}
+
+// .substrait.Rel right = 3;
+inline bool JoinRel::_internal_has_right() const {
+  return this != internal_default_instance() && right_ != nullptr;
+}
+inline bool JoinRel::has_right() const {
+  return _internal_has_right();
+}
+inline void JoinRel::clear_right() {
+  if (GetArenaForAllocation() == nullptr && right_ != nullptr) {
+    delete right_;
+  }
+  right_ = nullptr;
+}
+inline const ::substrait::Rel& JoinRel::_internal_right() const {
+  const ::substrait::Rel* p = right_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Rel&>(
+      ::substrait::_Rel_default_instance_);
+}
+inline const ::substrait::Rel& JoinRel::right() const {
+  // @@protoc_insertion_point(field_get:substrait.JoinRel.right)
+  return _internal_right();
+}
+inline void JoinRel::unsafe_arena_set_allocated_right(
+    ::substrait::Rel* right) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(right_);
+  }
+  right_ = right;
+  if (right) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.right)
+}
+inline ::substrait::Rel* JoinRel::release_right() {
+  
+  ::substrait::Rel* temp = right_;
+  right_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Rel* JoinRel::unsafe_arena_release_right() {
+  // @@protoc_insertion_point(field_release:substrait.JoinRel.right)
+  
+  ::substrait::Rel* temp = right_;
+  right_ = nullptr;
+  return temp;
+}
+inline ::substrait::Rel* JoinRel::_internal_mutable_right() {
+  
+  if (right_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation());
+    right_ = p;
+  }
+  return right_;
+}
+inline ::substrait::Rel* JoinRel::mutable_right() {
+  ::substrait::Rel* _msg = _internal_mutable_right();
+  // @@protoc_insertion_point(field_mutable:substrait.JoinRel.right)
+  return _msg;
+}
+inline void JoinRel::set_allocated_right(::substrait::Rel* right) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete right_;
+  }
+  if (right) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(right);
+    if (message_arena != submessage_arena) {
+      right = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, right, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  right_ = right;
+  // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.right)
+}
+
+// .substrait.Expression expression = 4;
+inline bool JoinRel::_internal_has_expression() const {
+  return this != internal_default_instance() && expression_ != nullptr;
+}
+inline bool JoinRel::has_expression() const {
+  return _internal_has_expression();
+}
+inline const ::substrait::Expression& JoinRel::_internal_expression() const {
+  const ::substrait::Expression* p = expression_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& JoinRel::expression() const {
+  // @@protoc_insertion_point(field_get:substrait.JoinRel.expression)
+  return _internal_expression();
+}
+inline void JoinRel::unsafe_arena_set_allocated_expression(
+    ::substrait::Expression* expression) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_);
+  }
+  expression_ = expression;
+  if (expression) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.expression)
+}
+inline ::substrait::Expression* JoinRel::release_expression() {
+  
+  ::substrait::Expression* temp = expression_;
+  expression_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* JoinRel::unsafe_arena_release_expression() {
+  // @@protoc_insertion_point(field_release:substrait.JoinRel.expression)
+  
+  ::substrait::Expression* temp = expression_;
+  expression_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* JoinRel::_internal_mutable_expression() {
+  
+  if (expression_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    expression_ = p;
+  }
+  return expression_;
+}
+inline ::substrait::Expression* JoinRel::mutable_expression() {
+  ::substrait::Expression* _msg = _internal_mutable_expression();
+  // @@protoc_insertion_point(field_mutable:substrait.JoinRel.expression)
+  return _msg;
+}
+inline void JoinRel::set_allocated_expression(::substrait::Expression* expression) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_);
+  }
+  if (expression) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression));
+    if (message_arena != submessage_arena) {
+      expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, expression, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  expression_ = expression;
+  // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.expression)
+}
+
+// .substrait.Expression post_join_filter = 5;
+inline bool JoinRel::_internal_has_post_join_filter() const {
+  return this != internal_default_instance() && post_join_filter_ != nullptr;
+}
+inline bool JoinRel::has_post_join_filter() const {
+  return _internal_has_post_join_filter();
+}
+inline const ::substrait::Expression& JoinRel::_internal_post_join_filter() const {
+  const ::substrait::Expression* p = post_join_filter_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& JoinRel::post_join_filter() const {
+  // @@protoc_insertion_point(field_get:substrait.JoinRel.post_join_filter)
+  return _internal_post_join_filter();
+}
+inline void JoinRel::unsafe_arena_set_allocated_post_join_filter(
+    ::substrait::Expression* post_join_filter) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_);
+  }
+  post_join_filter_ = post_join_filter;
+  if (post_join_filter) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.post_join_filter)
+}
+inline ::substrait::Expression* JoinRel::release_post_join_filter() {
+  
+  ::substrait::Expression* temp = post_join_filter_;
+  post_join_filter_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* JoinRel::unsafe_arena_release_post_join_filter() {
+  // @@protoc_insertion_point(field_release:substrait.JoinRel.post_join_filter)
+  
+  ::substrait::Expression* temp = post_join_filter_;
+  post_join_filter_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* JoinRel::_internal_mutable_post_join_filter() {
+  
+  if (post_join_filter_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    post_join_filter_ = p;
+  }
+  return post_join_filter_;
+}
+inline ::substrait::Expression* JoinRel::mutable_post_join_filter() {
+  ::substrait::Expression* _msg = _internal_mutable_post_join_filter();
+  // @@protoc_insertion_point(field_mutable:substrait.JoinRel.post_join_filter)
+  return _msg;
+}
+inline void JoinRel::set_allocated_post_join_filter(::substrait::Expression* post_join_filter) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_);
+  }
+  if (post_join_filter) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter));
+    if (message_arena != submessage_arena) {
+      post_join_filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, post_join_filter, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  post_join_filter_ = post_join_filter;
+  // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.post_join_filter)
+}
+
+// .substrait.JoinRel.JoinType type = 6;
+inline void JoinRel::clear_type() {
+  type_ = 0;
+}
+inline ::substrait::JoinRel_JoinType JoinRel::_internal_type() const {
+  return static_cast< ::substrait::JoinRel_JoinType >(type_);
+}
+inline ::substrait::JoinRel_JoinType JoinRel::type() const {
+  // @@protoc_insertion_point(field_get:substrait.JoinRel.type)
+  return _internal_type();
+}
+inline void JoinRel::_internal_set_type(::substrait::JoinRel_JoinType value) {
+  
+  type_ = value;
+}
+inline void JoinRel::set_type(::substrait::JoinRel_JoinType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:substrait.JoinRel.type)
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool JoinRel::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool JoinRel::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& JoinRel::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& JoinRel::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.JoinRel.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void JoinRel::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* JoinRel::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* JoinRel::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.JoinRel.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* JoinRel::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* JoinRel::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.JoinRel.advanced_extension)
+  return _msg;
+}
+inline void JoinRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.advanced_extension)
+}
+
+// -------------------------------------------------------------------
+
+// FetchRel
+
+// .substrait.RelCommon common = 1;
+inline bool FetchRel::_internal_has_common() const {
+  return this != internal_default_instance() && common_ != nullptr;
+}
+inline bool FetchRel::has_common() const {
+  return _internal_has_common();
+}
+inline void FetchRel::clear_common() {
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+}
+inline const ::substrait::RelCommon& FetchRel::_internal_common() const {
+  const ::substrait::RelCommon* p = common_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon&>(
+      ::substrait::_RelCommon_default_instance_);
+}
+inline const ::substrait::RelCommon& FetchRel::common() const {
+  // @@protoc_insertion_point(field_get:substrait.FetchRel.common)
+  return _internal_common();
+}
+inline void FetchRel::unsafe_arena_set_allocated_common(
+    ::substrait::RelCommon* common) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_);
+  }
+  common_ = common;
+  if (common) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FetchRel.common)
+}
+inline ::substrait::RelCommon* FetchRel::release_common() {
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon* FetchRel::unsafe_arena_release_common() {
+  // @@protoc_insertion_point(field_release:substrait.FetchRel.common)
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon* FetchRel::_internal_mutable_common() {
+  
+  if (common_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation());
+    common_ = p;
+  }
+  return common_;
+}
+inline ::substrait::RelCommon* FetchRel::mutable_common() {
+  ::substrait::RelCommon* _msg = _internal_mutable_common();
+  // @@protoc_insertion_point(field_mutable:substrait.FetchRel.common)
+  return _msg;
+}
+inline void FetchRel::set_allocated_common(::substrait::RelCommon* common) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete common_;
+  }
+  if (common) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common);
+    if (message_arena != submessage_arena) {
+      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, common, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  common_ = common;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FetchRel.common)
+}
+
+// .substrait.Rel input = 2;
+inline bool FetchRel::_internal_has_input() const {
+  return this != internal_default_instance() && input_ != nullptr;
+}
+inline bool FetchRel::has_input() const {
+  return _internal_has_input();
+}
+inline void FetchRel::clear_input() {
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+}
+inline const ::substrait::Rel& FetchRel::_internal_input() const {
+  const ::substrait::Rel* p = input_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Rel&>(
+      ::substrait::_Rel_default_instance_);
+}
+inline const ::substrait::Rel& FetchRel::input() const {
+  // @@protoc_insertion_point(field_get:substrait.FetchRel.input)
+  return _internal_input();
+}
+inline void FetchRel::unsafe_arena_set_allocated_input(
+    ::substrait::Rel* input) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_);
+  }
+  input_ = input;
+  if (input) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FetchRel.input)
+}
+inline ::substrait::Rel* FetchRel::release_input() {
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Rel* FetchRel::unsafe_arena_release_input() {
+  // @@protoc_insertion_point(field_release:substrait.FetchRel.input)
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+  return temp;
+}
+inline ::substrait::Rel* FetchRel::_internal_mutable_input() {
+  
+  if (input_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation());
+    input_ = p;
+  }
+  return input_;
+}
+inline ::substrait::Rel* FetchRel::mutable_input() {
+  ::substrait::Rel* _msg = _internal_mutable_input();
+  // @@protoc_insertion_point(field_mutable:substrait.FetchRel.input)
+  return _msg;
+}
+inline void FetchRel::set_allocated_input(::substrait::Rel* input) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete input_;
+  }
+  if (input) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input);
+    if (message_arena != submessage_arena) {
+      input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, input, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  input_ = input;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FetchRel.input)
+}
+
+// int64 offset = 3;
+inline void FetchRel::clear_offset() {
+  offset_ = int64_t{0};
+}
+inline int64_t FetchRel::_internal_offset() const {
+  return offset_;
+}
+inline int64_t FetchRel::offset() const {
+  // @@protoc_insertion_point(field_get:substrait.FetchRel.offset)
+  return _internal_offset();
+}
+inline void FetchRel::_internal_set_offset(int64_t value) {
+  
+  offset_ = value;
+}
+inline void FetchRel::set_offset(int64_t value) {
+  _internal_set_offset(value);
+  // @@protoc_insertion_point(field_set:substrait.FetchRel.offset)
+}
+
+// int64 count = 4;
+inline void FetchRel::clear_count() {
+  count_ = int64_t{0};
+}
+inline int64_t FetchRel::_internal_count() const {
+  return count_;
+}
+inline int64_t FetchRel::count() const {
+  // @@protoc_insertion_point(field_get:substrait.FetchRel.count)
+  return _internal_count();
+}
+inline void FetchRel::_internal_set_count(int64_t value) {
+  
+  count_ = value;
+}
+inline void FetchRel::set_count(int64_t value) {
+  _internal_set_count(value);
+  // @@protoc_insertion_point(field_set:substrait.FetchRel.count)
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool FetchRel::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool FetchRel::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& FetchRel::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& FetchRel::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.FetchRel.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void FetchRel::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FetchRel.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* FetchRel::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* FetchRel::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.FetchRel.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* FetchRel::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* FetchRel::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.FetchRel.advanced_extension)
+  return _msg;
+}
+inline void FetchRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FetchRel.advanced_extension)
+}
+
+// -------------------------------------------------------------------
+
+// AggregateRel_Grouping
+
+// repeated .substrait.Expression grouping_expressions = 1;
+inline int AggregateRel_Grouping::_internal_grouping_expressions_size() const {
+  return grouping_expressions_.size();
+}
+inline int AggregateRel_Grouping::grouping_expressions_size() const {
+  return _internal_grouping_expressions_size();
+}
+inline ::substrait::Expression* AggregateRel_Grouping::mutable_grouping_expressions(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.Grouping.grouping_expressions)
+  return grouping_expressions_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >*
+AggregateRel_Grouping::mutable_grouping_expressions() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.AggregateRel.Grouping.grouping_expressions)
+  return &grouping_expressions_;
+}
+inline const ::substrait::Expression& AggregateRel_Grouping::_internal_grouping_expressions(int index) const {
+  return grouping_expressions_.Get(index);
+}
+inline const ::substrait::Expression& AggregateRel_Grouping::grouping_expressions(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateRel.Grouping.grouping_expressions)
+  return _internal_grouping_expressions(index);
+}
+inline ::substrait::Expression* AggregateRel_Grouping::_internal_add_grouping_expressions() {
+  return grouping_expressions_.Add();
+}
+inline ::substrait::Expression* AggregateRel_Grouping::add_grouping_expressions() {
+  ::substrait::Expression* _add = _internal_add_grouping_expressions();
+  // @@protoc_insertion_point(field_add:substrait.AggregateRel.Grouping.grouping_expressions)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >&
+AggregateRel_Grouping::grouping_expressions() const {
+  // @@protoc_insertion_point(field_list:substrait.AggregateRel.Grouping.grouping_expressions)
+  return grouping_expressions_;
+}
+
+// -------------------------------------------------------------------
+
+// AggregateRel_Measure
+
+// .substrait.AggregateFunction measure = 1;
+inline bool AggregateRel_Measure::_internal_has_measure() const {
+  return this != internal_default_instance() && measure_ != nullptr;
+}
+inline bool AggregateRel_Measure::has_measure() const {
+  return _internal_has_measure();
+}
+inline const ::substrait::AggregateFunction& AggregateRel_Measure::_internal_measure() const {
+  const ::substrait::AggregateFunction* p = measure_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::AggregateFunction&>(
+      ::substrait::_AggregateFunction_default_instance_);
+}
+inline const ::substrait::AggregateFunction& AggregateRel_Measure::measure() const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateRel.Measure.measure)
+  return _internal_measure();
+}
+inline void AggregateRel_Measure::unsafe_arena_set_allocated_measure(
+    ::substrait::AggregateFunction* measure) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_);
+  }
+  measure_ = measure;
+  if (measure) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.Measure.measure)
+}
+inline ::substrait::AggregateFunction* AggregateRel_Measure::release_measure() {
+  
+  ::substrait::AggregateFunction* temp = measure_;
+  measure_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::AggregateFunction* AggregateRel_Measure::unsafe_arena_release_measure() {
+  // @@protoc_insertion_point(field_release:substrait.AggregateRel.Measure.measure)
+  
+  ::substrait::AggregateFunction* temp = measure_;
+  measure_ = nullptr;
+  return temp;
+}
+inline ::substrait::AggregateFunction* AggregateRel_Measure::_internal_mutable_measure() {
+  
+  if (measure_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::AggregateFunction>(GetArenaForAllocation());
+    measure_ = p;
+  }
+  return measure_;
+}
+inline ::substrait::AggregateFunction* AggregateRel_Measure::mutable_measure() {
+  ::substrait::AggregateFunction* _msg = _internal_mutable_measure();
+  // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.Measure.measure)
+  return _msg;
+}
+inline void AggregateRel_Measure::set_allocated_measure(::substrait::AggregateFunction* measure) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_);
+  }
+  if (measure) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure));
+    if (message_arena != submessage_arena) {
+      measure = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, measure, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  measure_ = measure;
+  // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.Measure.measure)
+}
+
+// .substrait.Expression filter = 2;
+inline bool AggregateRel_Measure::_internal_has_filter() const {
+  return this != internal_default_instance() && filter_ != nullptr;
+}
+inline bool AggregateRel_Measure::has_filter() const {
+  return _internal_has_filter();
+}
+inline const ::substrait::Expression& AggregateRel_Measure::_internal_filter() const {
+  const ::substrait::Expression* p = filter_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& AggregateRel_Measure::filter() const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateRel.Measure.filter)
+  return _internal_filter();
+}
+inline void AggregateRel_Measure::unsafe_arena_set_allocated_filter(
+    ::substrait::Expression* filter) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_);
+  }
+  filter_ = filter;
+  if (filter) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.Measure.filter)
+}
+inline ::substrait::Expression* AggregateRel_Measure::release_filter() {
+  
+  ::substrait::Expression* temp = filter_;
+  filter_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* AggregateRel_Measure::unsafe_arena_release_filter() {
+  // @@protoc_insertion_point(field_release:substrait.AggregateRel.Measure.filter)
+  
+  ::substrait::Expression* temp = filter_;
+  filter_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* AggregateRel_Measure::_internal_mutable_filter() {
+  
+  if (filter_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    filter_ = p;
+  }
+  return filter_;
+}
+inline ::substrait::Expression* AggregateRel_Measure::mutable_filter() {
+  ::substrait::Expression* _msg = _internal_mutable_filter();
+  // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.Measure.filter)
+  return _msg;
+}
+inline void AggregateRel_Measure::set_allocated_filter(::substrait::Expression* filter) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_);
+  }
+  if (filter) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter));
+    if (message_arena != submessage_arena) {
+      filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, filter, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  filter_ = filter;
+  // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.Measure.filter)
+}
+
+// -------------------------------------------------------------------
+
+// AggregateRel
+
+// .substrait.RelCommon common = 1;
+inline bool AggregateRel::_internal_has_common() const {
+  return this != internal_default_instance() && common_ != nullptr;
+}
+inline bool AggregateRel::has_common() const {
+  return _internal_has_common();
+}
+inline void AggregateRel::clear_common() {
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+}
+inline const ::substrait::RelCommon& AggregateRel::_internal_common() const {
+  const ::substrait::RelCommon* p = common_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon&>(
+      ::substrait::_RelCommon_default_instance_);
+}
+inline const ::substrait::RelCommon& AggregateRel::common() const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateRel.common)
+  return _internal_common();
+}
+inline void AggregateRel::unsafe_arena_set_allocated_common(
+    ::substrait::RelCommon* common) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_);
+  }
+  common_ = common;
+  if (common) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.common)
+}
+inline ::substrait::RelCommon* AggregateRel::release_common() {
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon* AggregateRel::unsafe_arena_release_common() {
+  // @@protoc_insertion_point(field_release:substrait.AggregateRel.common)
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon* AggregateRel::_internal_mutable_common() {
+  
+  if (common_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation());
+    common_ = p;
+  }
+  return common_;
+}
+inline ::substrait::RelCommon* AggregateRel::mutable_common() {
+  ::substrait::RelCommon* _msg = _internal_mutable_common();
+  // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.common)
+  return _msg;
+}
+inline void AggregateRel::set_allocated_common(::substrait::RelCommon* common) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete common_;
+  }
+  if (common) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common);
+    if (message_arena != submessage_arena) {
+      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, common, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  common_ = common;
+  // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.common)
+}
+
+// .substrait.Rel input = 2;
+inline bool AggregateRel::_internal_has_input() const {
+  return this != internal_default_instance() && input_ != nullptr;
+}
+inline bool AggregateRel::has_input() const {
+  return _internal_has_input();
+}
+inline void AggregateRel::clear_input() {
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+}
+inline const ::substrait::Rel& AggregateRel::_internal_input() const {
+  const ::substrait::Rel* p = input_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Rel&>(
+      ::substrait::_Rel_default_instance_);
+}
+inline const ::substrait::Rel& AggregateRel::input() const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateRel.input)
+  return _internal_input();
+}
+inline void AggregateRel::unsafe_arena_set_allocated_input(
+    ::substrait::Rel* input) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_);
+  }
+  input_ = input;
+  if (input) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.input)
+}
+inline ::substrait::Rel* AggregateRel::release_input() {
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Rel* AggregateRel::unsafe_arena_release_input() {
+  // @@protoc_insertion_point(field_release:substrait.AggregateRel.input)
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+  return temp;
+}
+inline ::substrait::Rel* AggregateRel::_internal_mutable_input() {
+  
+  if (input_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation());
+    input_ = p;
+  }
+  return input_;
+}
+inline ::substrait::Rel* AggregateRel::mutable_input() {
+  ::substrait::Rel* _msg = _internal_mutable_input();
+  // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.input)
+  return _msg;
+}
+inline void AggregateRel::set_allocated_input(::substrait::Rel* input) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete input_;
+  }
+  if (input) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input);
+    if (message_arena != submessage_arena) {
+      input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, input, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  input_ = input;
+  // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.input)
+}
+
+// repeated .substrait.AggregateRel.Grouping groupings = 3;
+inline int AggregateRel::_internal_groupings_size() const {
+  return groupings_.size();
+}
+inline int AggregateRel::groupings_size() const {
+  return _internal_groupings_size();
+}
+inline void AggregateRel::clear_groupings() {
+  groupings_.Clear();
+}
+inline ::substrait::AggregateRel_Grouping* AggregateRel::mutable_groupings(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.groupings)
+  return groupings_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >*
+AggregateRel::mutable_groupings() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.AggregateRel.groupings)
+  return &groupings_;
+}
+inline const ::substrait::AggregateRel_Grouping& AggregateRel::_internal_groupings(int index) const {
+  return groupings_.Get(index);
+}
+inline const ::substrait::AggregateRel_Grouping& AggregateRel::groupings(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateRel.groupings)
+  return _internal_groupings(index);
+}
+inline ::substrait::AggregateRel_Grouping* AggregateRel::_internal_add_groupings() {
+  return groupings_.Add();
+}
+inline ::substrait::AggregateRel_Grouping* AggregateRel::add_groupings() {
+  ::substrait::AggregateRel_Grouping* _add = _internal_add_groupings();
+  // @@protoc_insertion_point(field_add:substrait.AggregateRel.groupings)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >&
+AggregateRel::groupings() const {
+  // @@protoc_insertion_point(field_list:substrait.AggregateRel.groupings)
+  return groupings_;
+}
+
+// repeated .substrait.AggregateRel.Measure measures = 4;
+inline int AggregateRel::_internal_measures_size() const {
+  return measures_.size();
+}
+inline int AggregateRel::measures_size() const {
+  return _internal_measures_size();
+}
+inline void AggregateRel::clear_measures() {
+  measures_.Clear();
+}
+inline ::substrait::AggregateRel_Measure* AggregateRel::mutable_measures(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.measures)
+  return measures_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >*
+AggregateRel::mutable_measures() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.AggregateRel.measures)
+  return &measures_;
+}
+inline const ::substrait::AggregateRel_Measure& AggregateRel::_internal_measures(int index) const {
+  return measures_.Get(index);
+}
+inline const ::substrait::AggregateRel_Measure& AggregateRel::measures(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateRel.measures)
+  return _internal_measures(index);
+}
+inline ::substrait::AggregateRel_Measure* AggregateRel::_internal_add_measures() {
+  return measures_.Add();
+}
+inline ::substrait::AggregateRel_Measure* AggregateRel::add_measures() {
+  ::substrait::AggregateRel_Measure* _add = _internal_add_measures();
+  // @@protoc_insertion_point(field_add:substrait.AggregateRel.measures)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >&
+AggregateRel::measures() const {
+  // @@protoc_insertion_point(field_list:substrait.AggregateRel.measures)
+  return measures_;
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool AggregateRel::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool AggregateRel::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& AggregateRel::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& AggregateRel::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.AggregateRel.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void AggregateRel::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* AggregateRel::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* AggregateRel::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.AggregateRel.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* AggregateRel::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* AggregateRel::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.advanced_extension)
+  return _msg;
+}
+inline void AggregateRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.advanced_extension)
+}
+
+// -------------------------------------------------------------------
+
+// SortRel
+
+// .substrait.RelCommon common = 1;
+inline bool SortRel::_internal_has_common() const {
+  return this != internal_default_instance() && common_ != nullptr;
+}
+inline bool SortRel::has_common() const {
+  return _internal_has_common();
+}
+inline void SortRel::clear_common() {
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+}
+inline const ::substrait::RelCommon& SortRel::_internal_common() const {
+  const ::substrait::RelCommon* p = common_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon&>(
+      ::substrait::_RelCommon_default_instance_);
+}
+inline const ::substrait::RelCommon& SortRel::common() const {
+  // @@protoc_insertion_point(field_get:substrait.SortRel.common)
+  return _internal_common();
+}
+inline void SortRel::unsafe_arena_set_allocated_common(
+    ::substrait::RelCommon* common) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_);
+  }
+  common_ = common;
+  if (common) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SortRel.common)
+}
+inline ::substrait::RelCommon* SortRel::release_common() {
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon* SortRel::unsafe_arena_release_common() {
+  // @@protoc_insertion_point(field_release:substrait.SortRel.common)
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon* SortRel::_internal_mutable_common() {
+  
+  if (common_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation());
+    common_ = p;
+  }
+  return common_;
+}
+inline ::substrait::RelCommon* SortRel::mutable_common() {
+  ::substrait::RelCommon* _msg = _internal_mutable_common();
+  // @@protoc_insertion_point(field_mutable:substrait.SortRel.common)
+  return _msg;
+}
+inline void SortRel::set_allocated_common(::substrait::RelCommon* common) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete common_;
+  }
+  if (common) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common);
+    if (message_arena != submessage_arena) {
+      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, common, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  common_ = common;
+  // @@protoc_insertion_point(field_set_allocated:substrait.SortRel.common)
+}
+
+// .substrait.Rel input = 2;
+inline bool SortRel::_internal_has_input() const {
+  return this != internal_default_instance() && input_ != nullptr;
+}
+inline bool SortRel::has_input() const {
+  return _internal_has_input();
+}
+inline void SortRel::clear_input() {
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+}
+inline const ::substrait::Rel& SortRel::_internal_input() const {
+  const ::substrait::Rel* p = input_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Rel&>(
+      ::substrait::_Rel_default_instance_);
+}
+inline const ::substrait::Rel& SortRel::input() const {
+  // @@protoc_insertion_point(field_get:substrait.SortRel.input)
+  return _internal_input();
+}
+inline void SortRel::unsafe_arena_set_allocated_input(
+    ::substrait::Rel* input) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_);
+  }
+  input_ = input;
+  if (input) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SortRel.input)
+}
+inline ::substrait::Rel* SortRel::release_input() {
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Rel* SortRel::unsafe_arena_release_input() {
+  // @@protoc_insertion_point(field_release:substrait.SortRel.input)
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+  return temp;
+}
+inline ::substrait::Rel* SortRel::_internal_mutable_input() {
+  
+  if (input_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation());
+    input_ = p;
+  }
+  return input_;
+}
+inline ::substrait::Rel* SortRel::mutable_input() {
+  ::substrait::Rel* _msg = _internal_mutable_input();
+  // @@protoc_insertion_point(field_mutable:substrait.SortRel.input)
+  return _msg;
+}
+inline void SortRel::set_allocated_input(::substrait::Rel* input) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete input_;
+  }
+  if (input) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input);
+    if (message_arena != submessage_arena) {
+      input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, input, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  input_ = input;
+  // @@protoc_insertion_point(field_set_allocated:substrait.SortRel.input)
+}
+
+// repeated .substrait.SortField sorts = 3;
+inline int SortRel::_internal_sorts_size() const {
+  return sorts_.size();
+}
+inline int SortRel::sorts_size() const {
+  return _internal_sorts_size();
+}
+inline ::substrait::SortField* SortRel::mutable_sorts(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.SortRel.sorts)
+  return sorts_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >*
+SortRel::mutable_sorts() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.SortRel.sorts)
+  return &sorts_;
+}
+inline const ::substrait::SortField& SortRel::_internal_sorts(int index) const {
+  return sorts_.Get(index);
+}
+inline const ::substrait::SortField& SortRel::sorts(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.SortRel.sorts)
+  return _internal_sorts(index);
+}
+inline ::substrait::SortField* SortRel::_internal_add_sorts() {
+  return sorts_.Add();
+}
+inline ::substrait::SortField* SortRel::add_sorts() {
+  ::substrait::SortField* _add = _internal_add_sorts();
+  // @@protoc_insertion_point(field_add:substrait.SortRel.sorts)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >&
+SortRel::sorts() const {
+  // @@protoc_insertion_point(field_list:substrait.SortRel.sorts)
+  return sorts_;
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool SortRel::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool SortRel::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& SortRel::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& SortRel::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.SortRel.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void SortRel::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SortRel.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* SortRel::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* SortRel::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.SortRel.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* SortRel::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* SortRel::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.SortRel.advanced_extension)
+  return _msg;
+}
+inline void SortRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.SortRel.advanced_extension)
+}
+
+// -------------------------------------------------------------------
+
+// FilterRel
+
+// .substrait.RelCommon common = 1;
+inline bool FilterRel::_internal_has_common() const {
+  return this != internal_default_instance() && common_ != nullptr;
+}
+inline bool FilterRel::has_common() const {
+  return _internal_has_common();
+}
+inline void FilterRel::clear_common() {
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+}
+inline const ::substrait::RelCommon& FilterRel::_internal_common() const {
+  const ::substrait::RelCommon* p = common_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon&>(
+      ::substrait::_RelCommon_default_instance_);
+}
+inline const ::substrait::RelCommon& FilterRel::common() const {
+  // @@protoc_insertion_point(field_get:substrait.FilterRel.common)
+  return _internal_common();
+}
+inline void FilterRel::unsafe_arena_set_allocated_common(
+    ::substrait::RelCommon* common) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_);
+  }
+  common_ = common;
+  if (common) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FilterRel.common)
+}
+inline ::substrait::RelCommon* FilterRel::release_common() {
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon* FilterRel::unsafe_arena_release_common() {
+  // @@protoc_insertion_point(field_release:substrait.FilterRel.common)
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon* FilterRel::_internal_mutable_common() {
+  
+  if (common_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation());
+    common_ = p;
+  }
+  return common_;
+}
+inline ::substrait::RelCommon* FilterRel::mutable_common() {
+  ::substrait::RelCommon* _msg = _internal_mutable_common();
+  // @@protoc_insertion_point(field_mutable:substrait.FilterRel.common)
+  return _msg;
+}
+inline void FilterRel::set_allocated_common(::substrait::RelCommon* common) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete common_;
+  }
+  if (common) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common);
+    if (message_arena != submessage_arena) {
+      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, common, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  common_ = common;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FilterRel.common)
+}
+
+// .substrait.Rel input = 2;
+inline bool FilterRel::_internal_has_input() const {
+  return this != internal_default_instance() && input_ != nullptr;
+}
+inline bool FilterRel::has_input() const {
+  return _internal_has_input();
+}
+inline void FilterRel::clear_input() {
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+}
+inline const ::substrait::Rel& FilterRel::_internal_input() const {
+  const ::substrait::Rel* p = input_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Rel&>(
+      ::substrait::_Rel_default_instance_);
+}
+inline const ::substrait::Rel& FilterRel::input() const {
+  // @@protoc_insertion_point(field_get:substrait.FilterRel.input)
+  return _internal_input();
+}
+inline void FilterRel::unsafe_arena_set_allocated_input(
+    ::substrait::Rel* input) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_);
+  }
+  input_ = input;
+  if (input) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FilterRel.input)
+}
+inline ::substrait::Rel* FilterRel::release_input() {
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Rel* FilterRel::unsafe_arena_release_input() {
+  // @@protoc_insertion_point(field_release:substrait.FilterRel.input)
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+  return temp;
+}
+inline ::substrait::Rel* FilterRel::_internal_mutable_input() {
+  
+  if (input_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation());
+    input_ = p;
+  }
+  return input_;
+}
+inline ::substrait::Rel* FilterRel::mutable_input() {
+  ::substrait::Rel* _msg = _internal_mutable_input();
+  // @@protoc_insertion_point(field_mutable:substrait.FilterRel.input)
+  return _msg;
+}
+inline void FilterRel::set_allocated_input(::substrait::Rel* input) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete input_;
+  }
+  if (input) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input);
+    if (message_arena != submessage_arena) {
+      input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, input, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  input_ = input;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FilterRel.input)
+}
+
+// .substrait.Expression condition = 3;
+inline bool FilterRel::_internal_has_condition() const {
+  return this != internal_default_instance() && condition_ != nullptr;
+}
+inline bool FilterRel::has_condition() const {
+  return _internal_has_condition();
+}
+inline const ::substrait::Expression& FilterRel::_internal_condition() const {
+  const ::substrait::Expression* p = condition_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Expression&>(
+      ::substrait::_Expression_default_instance_);
+}
+inline const ::substrait::Expression& FilterRel::condition() const {
+  // @@protoc_insertion_point(field_get:substrait.FilterRel.condition)
+  return _internal_condition();
+}
+inline void FilterRel::unsafe_arena_set_allocated_condition(
+    ::substrait::Expression* condition) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_);
+  }
+  condition_ = condition;
+  if (condition) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FilterRel.condition)
+}
+inline ::substrait::Expression* FilterRel::release_condition() {
+  
+  ::substrait::Expression* temp = condition_;
+  condition_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Expression* FilterRel::unsafe_arena_release_condition() {
+  // @@protoc_insertion_point(field_release:substrait.FilterRel.condition)
+  
+  ::substrait::Expression* temp = condition_;
+  condition_ = nullptr;
+  return temp;
+}
+inline ::substrait::Expression* FilterRel::_internal_mutable_condition() {
+  
+  if (condition_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation());
+    condition_ = p;
+  }
+  return condition_;
+}
+inline ::substrait::Expression* FilterRel::mutable_condition() {
+  ::substrait::Expression* _msg = _internal_mutable_condition();
+  // @@protoc_insertion_point(field_mutable:substrait.FilterRel.condition)
+  return _msg;
+}
+inline void FilterRel::set_allocated_condition(::substrait::Expression* condition) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_);
+  }
+  if (condition) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition));
+    if (message_arena != submessage_arena) {
+      condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, condition, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  condition_ = condition;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FilterRel.condition)
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool FilterRel::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool FilterRel::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& FilterRel::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& FilterRel::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.FilterRel.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void FilterRel::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FilterRel.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* FilterRel::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* FilterRel::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.FilterRel.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* FilterRel::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* FilterRel::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.FilterRel.advanced_extension)
+  return _msg;
+}
+inline void FilterRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.FilterRel.advanced_extension)
+}
+
+// -------------------------------------------------------------------
+
+// SetRel
+
+// .substrait.RelCommon common = 1;
+inline bool SetRel::_internal_has_common() const {
+  return this != internal_default_instance() && common_ != nullptr;
+}
+inline bool SetRel::has_common() const {
+  return _internal_has_common();
+}
+inline void SetRel::clear_common() {
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+}
+inline const ::substrait::RelCommon& SetRel::_internal_common() const {
+  const ::substrait::RelCommon* p = common_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon&>(
+      ::substrait::_RelCommon_default_instance_);
+}
+inline const ::substrait::RelCommon& SetRel::common() const {
+  // @@protoc_insertion_point(field_get:substrait.SetRel.common)
+  return _internal_common();
+}
+inline void SetRel::unsafe_arena_set_allocated_common(
+    ::substrait::RelCommon* common) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_);
+  }
+  common_ = common;
+  if (common) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SetRel.common)
+}
+inline ::substrait::RelCommon* SetRel::release_common() {
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon* SetRel::unsafe_arena_release_common() {
+  // @@protoc_insertion_point(field_release:substrait.SetRel.common)
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon* SetRel::_internal_mutable_common() {
+  
+  if (common_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation());
+    common_ = p;
+  }
+  return common_;
+}
+inline ::substrait::RelCommon* SetRel::mutable_common() {
+  ::substrait::RelCommon* _msg = _internal_mutable_common();
+  // @@protoc_insertion_point(field_mutable:substrait.SetRel.common)
+  return _msg;
+}
+inline void SetRel::set_allocated_common(::substrait::RelCommon* common) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete common_;
+  }
+  if (common) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common);
+    if (message_arena != submessage_arena) {
+      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, common, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  common_ = common;
+  // @@protoc_insertion_point(field_set_allocated:substrait.SetRel.common)
+}
+
+// repeated .substrait.Rel inputs = 2;
+inline int SetRel::_internal_inputs_size() const {
+  return inputs_.size();
+}
+inline int SetRel::inputs_size() const {
+  return _internal_inputs_size();
+}
+inline void SetRel::clear_inputs() {
+  inputs_.Clear();
+}
+inline ::substrait::Rel* SetRel::mutable_inputs(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.SetRel.inputs)
+  return inputs_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >*
+SetRel::mutable_inputs() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.SetRel.inputs)
+  return &inputs_;
+}
+inline const ::substrait::Rel& SetRel::_internal_inputs(int index) const {
+  return inputs_.Get(index);
+}
+inline const ::substrait::Rel& SetRel::inputs(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.SetRel.inputs)
+  return _internal_inputs(index);
+}
+inline ::substrait::Rel* SetRel::_internal_add_inputs() {
+  return inputs_.Add();
+}
+inline ::substrait::Rel* SetRel::add_inputs() {
+  ::substrait::Rel* _add = _internal_add_inputs();
+  // @@protoc_insertion_point(field_add:substrait.SetRel.inputs)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >&
+SetRel::inputs() const {
+  // @@protoc_insertion_point(field_list:substrait.SetRel.inputs)
+  return inputs_;
+}
+
+// .substrait.SetRel.SetOp op = 3;
+inline void SetRel::clear_op() {
+  op_ = 0;
+}
+inline ::substrait::SetRel_SetOp SetRel::_internal_op() const {
+  return static_cast< ::substrait::SetRel_SetOp >(op_);
+}
+inline ::substrait::SetRel_SetOp SetRel::op() const {
+  // @@protoc_insertion_point(field_get:substrait.SetRel.op)
+  return _internal_op();
+}
+inline void SetRel::_internal_set_op(::substrait::SetRel_SetOp value) {
+  
+  op_ = value;
+}
+inline void SetRel::set_op(::substrait::SetRel_SetOp value) {
+  _internal_set_op(value);
+  // @@protoc_insertion_point(field_set:substrait.SetRel.op)
+}
+
+// .substrait.extensions.AdvancedExtension advanced_extension = 10;
+inline bool SetRel::_internal_has_advanced_extension() const {
+  return this != internal_default_instance() && advanced_extension_ != nullptr;
+}
+inline bool SetRel::has_advanced_extension() const {
+  return _internal_has_advanced_extension();
+}
+inline const ::substrait::extensions::AdvancedExtension& SetRel::_internal_advanced_extension() const {
+  const ::substrait::extensions::AdvancedExtension* p = advanced_extension_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::extensions::AdvancedExtension&>(
+      ::substrait::extensions::_AdvancedExtension_default_instance_);
+}
+inline const ::substrait::extensions::AdvancedExtension& SetRel::advanced_extension() const {
+  // @@protoc_insertion_point(field_get:substrait.SetRel.advanced_extension)
+  return _internal_advanced_extension();
+}
+inline void SetRel::unsafe_arena_set_allocated_advanced_extension(
+    ::substrait::extensions::AdvancedExtension* advanced_extension) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  advanced_extension_ = advanced_extension;
+  if (advanced_extension) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SetRel.advanced_extension)
+}
+inline ::substrait::extensions::AdvancedExtension* SetRel::release_advanced_extension() {
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* SetRel::unsafe_arena_release_advanced_extension() {
+  // @@protoc_insertion_point(field_release:substrait.SetRel.advanced_extension)
+  
+  ::substrait::extensions::AdvancedExtension* temp = advanced_extension_;
+  advanced_extension_ = nullptr;
+  return temp;
+}
+inline ::substrait::extensions::AdvancedExtension* SetRel::_internal_mutable_advanced_extension() {
+  
+  if (advanced_extension_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation());
+    advanced_extension_ = p;
+  }
+  return advanced_extension_;
+}
+inline ::substrait::extensions::AdvancedExtension* SetRel::mutable_advanced_extension() {
+  ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension();
+  // @@protoc_insertion_point(field_mutable:substrait.SetRel.advanced_extension)
+  return _msg;
+}
+inline void SetRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_);
+  }
+  if (advanced_extension) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension));
+    if (message_arena != submessage_arena) {
+      advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, advanced_extension, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  advanced_extension_ = advanced_extension;
+  // @@protoc_insertion_point(field_set_allocated:substrait.SetRel.advanced_extension)
+}
+
+// -------------------------------------------------------------------
+
+// ExtensionSingleRel
+
+// .substrait.RelCommon common = 1;
+inline bool ExtensionSingleRel::_internal_has_common() const {
+  return this != internal_default_instance() && common_ != nullptr;
+}
+inline bool ExtensionSingleRel::has_common() const {
+  return _internal_has_common();
+}
+inline void ExtensionSingleRel::clear_common() {
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+}
+inline const ::substrait::RelCommon& ExtensionSingleRel::_internal_common() const {
+  const ::substrait::RelCommon* p = common_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon&>(
+      ::substrait::_RelCommon_default_instance_);
+}
+inline const ::substrait::RelCommon& ExtensionSingleRel::common() const {
+  // @@protoc_insertion_point(field_get:substrait.ExtensionSingleRel.common)
+  return _internal_common();
+}
+inline void ExtensionSingleRel::unsafe_arena_set_allocated_common(
+    ::substrait::RelCommon* common) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_);
+  }
+  common_ = common;
+  if (common) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionSingleRel.common)
+}
+inline ::substrait::RelCommon* ExtensionSingleRel::release_common() {
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon* ExtensionSingleRel::unsafe_arena_release_common() {
+  // @@protoc_insertion_point(field_release:substrait.ExtensionSingleRel.common)
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon* ExtensionSingleRel::_internal_mutable_common() {
+  
+  if (common_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation());
+    common_ = p;
+  }
+  return common_;
+}
+inline ::substrait::RelCommon* ExtensionSingleRel::mutable_common() {
+  ::substrait::RelCommon* _msg = _internal_mutable_common();
+  // @@protoc_insertion_point(field_mutable:substrait.ExtensionSingleRel.common)
+  return _msg;
+}
+inline void ExtensionSingleRel::set_allocated_common(::substrait::RelCommon* common) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete common_;
+  }
+  if (common) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common);
+    if (message_arena != submessage_arena) {
+      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, common, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  common_ = common;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionSingleRel.common)
+}
+
+// .substrait.Rel input = 2;
+inline bool ExtensionSingleRel::_internal_has_input() const {
+  return this != internal_default_instance() && input_ != nullptr;
+}
+inline bool ExtensionSingleRel::has_input() const {
+  return _internal_has_input();
+}
+inline void ExtensionSingleRel::clear_input() {
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+}
+inline const ::substrait::Rel& ExtensionSingleRel::_internal_input() const {
+  const ::substrait::Rel* p = input_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Rel&>(
+      ::substrait::_Rel_default_instance_);
+}
+inline const ::substrait::Rel& ExtensionSingleRel::input() const {
+  // @@protoc_insertion_point(field_get:substrait.ExtensionSingleRel.input)
+  return _internal_input();
+}
+inline void ExtensionSingleRel::unsafe_arena_set_allocated_input(
+    ::substrait::Rel* input) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_);
+  }
+  input_ = input;
+  if (input) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionSingleRel.input)
+}
+inline ::substrait::Rel* ExtensionSingleRel::release_input() {
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Rel* ExtensionSingleRel::unsafe_arena_release_input() {
+  // @@protoc_insertion_point(field_release:substrait.ExtensionSingleRel.input)
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+  return temp;
+}
+inline ::substrait::Rel* ExtensionSingleRel::_internal_mutable_input() {
+  
+  if (input_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation());
+    input_ = p;
+  }
+  return input_;
+}
+inline ::substrait::Rel* ExtensionSingleRel::mutable_input() {
+  ::substrait::Rel* _msg = _internal_mutable_input();
+  // @@protoc_insertion_point(field_mutable:substrait.ExtensionSingleRel.input)
+  return _msg;
+}
+inline void ExtensionSingleRel::set_allocated_input(::substrait::Rel* input) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete input_;
+  }
+  if (input) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input);
+    if (message_arena != submessage_arena) {
+      input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, input, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  input_ = input;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionSingleRel.input)
+}
+
+// .google.protobuf.Any detail = 3;
+inline bool ExtensionSingleRel::_internal_has_detail() const {
+  return this != internal_default_instance() && detail_ != nullptr;
+}
+inline bool ExtensionSingleRel::has_detail() const {
+  return _internal_has_detail();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::_internal_detail() const {
+  const ::PROTOBUF_NAMESPACE_ID::Any* p = detail_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
+      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::detail() const {
+  // @@protoc_insertion_point(field_get:substrait.ExtensionSingleRel.detail)
+  return _internal_detail();
+}
+inline void ExtensionSingleRel::unsafe_arena_set_allocated_detail(
+    ::PROTOBUF_NAMESPACE_ID::Any* detail) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_);
+  }
+  detail_ = detail;
+  if (detail) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionSingleRel.detail)
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::release_detail() {
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_;
+  detail_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::unsafe_arena_release_detail() {
+  // @@protoc_insertion_point(field_release:substrait.ExtensionSingleRel.detail)
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_;
+  detail_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::_internal_mutable_detail() {
+  
+  if (detail_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
+    detail_ = p;
+  }
+  return detail_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::mutable_detail() {
+  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_detail();
+  // @@protoc_insertion_point(field_mutable:substrait.ExtensionSingleRel.detail)
+  return _msg;
+}
+inline void ExtensionSingleRel::set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_);
+  }
+  if (detail) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail));
+    if (message_arena != submessage_arena) {
+      detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, detail, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  detail_ = detail;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionSingleRel.detail)
+}
+
+// -------------------------------------------------------------------
+
+// ExtensionLeafRel
+
+// .substrait.RelCommon common = 1;
+inline bool ExtensionLeafRel::_internal_has_common() const {
+  return this != internal_default_instance() && common_ != nullptr;
+}
+inline bool ExtensionLeafRel::has_common() const {
+  return _internal_has_common();
+}
+inline void ExtensionLeafRel::clear_common() {
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+}
+inline const ::substrait::RelCommon& ExtensionLeafRel::_internal_common() const {
+  const ::substrait::RelCommon* p = common_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon&>(
+      ::substrait::_RelCommon_default_instance_);
+}
+inline const ::substrait::RelCommon& ExtensionLeafRel::common() const {
+  // @@protoc_insertion_point(field_get:substrait.ExtensionLeafRel.common)
+  return _internal_common();
+}
+inline void ExtensionLeafRel::unsafe_arena_set_allocated_common(
+    ::substrait::RelCommon* common) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_);
+  }
+  common_ = common;
+  if (common) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionLeafRel.common)
+}
+inline ::substrait::RelCommon* ExtensionLeafRel::release_common() {
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon* ExtensionLeafRel::unsafe_arena_release_common() {
+  // @@protoc_insertion_point(field_release:substrait.ExtensionLeafRel.common)
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon* ExtensionLeafRel::_internal_mutable_common() {
+  
+  if (common_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation());
+    common_ = p;
+  }
+  return common_;
+}
+inline ::substrait::RelCommon* ExtensionLeafRel::mutable_common() {
+  ::substrait::RelCommon* _msg = _internal_mutable_common();
+  // @@protoc_insertion_point(field_mutable:substrait.ExtensionLeafRel.common)
+  return _msg;
+}
+inline void ExtensionLeafRel::set_allocated_common(::substrait::RelCommon* common) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete common_;
+  }
+  if (common) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common);
+    if (message_arena != submessage_arena) {
+      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, common, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  common_ = common;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionLeafRel.common)
+}
+
+// .google.protobuf.Any detail = 2;
+inline bool ExtensionLeafRel::_internal_has_detail() const {
+  return this != internal_default_instance() && detail_ != nullptr;
+}
+inline bool ExtensionLeafRel::has_detail() const {
+  return _internal_has_detail();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::_internal_detail() const {
+  const ::PROTOBUF_NAMESPACE_ID::Any* p = detail_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
+      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::detail() const {
+  // @@protoc_insertion_point(field_get:substrait.ExtensionLeafRel.detail)
+  return _internal_detail();
+}
+inline void ExtensionLeafRel::unsafe_arena_set_allocated_detail(
+    ::PROTOBUF_NAMESPACE_ID::Any* detail) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_);
+  }
+  detail_ = detail;
+  if (detail) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionLeafRel.detail)
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::release_detail() {
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_;
+  detail_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::unsafe_arena_release_detail() {
+  // @@protoc_insertion_point(field_release:substrait.ExtensionLeafRel.detail)
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_;
+  detail_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::_internal_mutable_detail() {
+  
+  if (detail_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
+    detail_ = p;
+  }
+  return detail_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::mutable_detail() {
+  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_detail();
+  // @@protoc_insertion_point(field_mutable:substrait.ExtensionLeafRel.detail)
+  return _msg;
+}
+inline void ExtensionLeafRel::set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_);
+  }
+  if (detail) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail));
+    if (message_arena != submessage_arena) {
+      detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, detail, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  detail_ = detail;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionLeafRel.detail)
+}
+
+// -------------------------------------------------------------------
+
+// ExtensionMultiRel
+
+// .substrait.RelCommon common = 1;
+inline bool ExtensionMultiRel::_internal_has_common() const {
+  return this != internal_default_instance() && common_ != nullptr;
+}
+inline bool ExtensionMultiRel::has_common() const {
+  return _internal_has_common();
+}
+inline void ExtensionMultiRel::clear_common() {
+  if (GetArenaForAllocation() == nullptr && common_ != nullptr) {
+    delete common_;
+  }
+  common_ = nullptr;
+}
+inline const ::substrait::RelCommon& ExtensionMultiRel::_internal_common() const {
+  const ::substrait::RelCommon* p = common_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::RelCommon&>(
+      ::substrait::_RelCommon_default_instance_);
+}
+inline const ::substrait::RelCommon& ExtensionMultiRel::common() const {
+  // @@protoc_insertion_point(field_get:substrait.ExtensionMultiRel.common)
+  return _internal_common();
+}
+inline void ExtensionMultiRel::unsafe_arena_set_allocated_common(
+    ::substrait::RelCommon* common) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_);
+  }
+  common_ = common;
+  if (common) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionMultiRel.common)
+}
+inline ::substrait::RelCommon* ExtensionMultiRel::release_common() {
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::RelCommon* ExtensionMultiRel::unsafe_arena_release_common() {
+  // @@protoc_insertion_point(field_release:substrait.ExtensionMultiRel.common)
+  
+  ::substrait::RelCommon* temp = common_;
+  common_ = nullptr;
+  return temp;
+}
+inline ::substrait::RelCommon* ExtensionMultiRel::_internal_mutable_common() {
+  
+  if (common_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation());
+    common_ = p;
+  }
+  return common_;
+}
+inline ::substrait::RelCommon* ExtensionMultiRel::mutable_common() {
+  ::substrait::RelCommon* _msg = _internal_mutable_common();
+  // @@protoc_insertion_point(field_mutable:substrait.ExtensionMultiRel.common)
+  return _msg;
+}
+inline void ExtensionMultiRel::set_allocated_common(::substrait::RelCommon* common) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete common_;
+  }
+  if (common) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common);
+    if (message_arena != submessage_arena) {
+      common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, common, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  common_ = common;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionMultiRel.common)
+}
+
+// repeated .substrait.Rel inputs = 2;
+inline int ExtensionMultiRel::_internal_inputs_size() const {
+  return inputs_.size();
+}
+inline int ExtensionMultiRel::inputs_size() const {
+  return _internal_inputs_size();
+}
+inline void ExtensionMultiRel::clear_inputs() {
+  inputs_.Clear();
+}
+inline ::substrait::Rel* ExtensionMultiRel::mutable_inputs(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.ExtensionMultiRel.inputs)
+  return inputs_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >*
+ExtensionMultiRel::mutable_inputs() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.ExtensionMultiRel.inputs)
+  return &inputs_;
+}
+inline const ::substrait::Rel& ExtensionMultiRel::_internal_inputs(int index) const {
+  return inputs_.Get(index);
+}
+inline const ::substrait::Rel& ExtensionMultiRel::inputs(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.ExtensionMultiRel.inputs)
+  return _internal_inputs(index);
+}
+inline ::substrait::Rel* ExtensionMultiRel::_internal_add_inputs() {
+  return inputs_.Add();
+}
+inline ::substrait::Rel* ExtensionMultiRel::add_inputs() {
+  ::substrait::Rel* _add = _internal_add_inputs();
+  // @@protoc_insertion_point(field_add:substrait.ExtensionMultiRel.inputs)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >&
+ExtensionMultiRel::inputs() const {
+  // @@protoc_insertion_point(field_list:substrait.ExtensionMultiRel.inputs)
+  return inputs_;
+}
+
+// .google.protobuf.Any detail = 3;
+inline bool ExtensionMultiRel::_internal_has_detail() const {
+  return this != internal_default_instance() && detail_ != nullptr;
+}
+inline bool ExtensionMultiRel::has_detail() const {
+  return _internal_has_detail();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::_internal_detail() const {
+  const ::PROTOBUF_NAMESPACE_ID::Any* p = detail_;
+  return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
+      ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::detail() const {
+  // @@protoc_insertion_point(field_get:substrait.ExtensionMultiRel.detail)
+  return _internal_detail();
+}
+inline void ExtensionMultiRel::unsafe_arena_set_allocated_detail(
+    ::PROTOBUF_NAMESPACE_ID::Any* detail) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_);
+  }
+  detail_ = detail;
+  if (detail) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionMultiRel.detail)
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::release_detail() {
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_;
+  detail_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::unsafe_arena_release_detail() {
+  // @@protoc_insertion_point(field_release:substrait.ExtensionMultiRel.detail)
+  
+  ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_;
+  detail_ = nullptr;
+  return temp;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::_internal_mutable_detail() {
+  
+  if (detail_ == nullptr) {
+    auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
+    detail_ = p;
+  }
+  return detail_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::mutable_detail() {
+  ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_detail();
+  // @@protoc_insertion_point(field_mutable:substrait.ExtensionMultiRel.detail)
+  return _msg;
+}
+inline void ExtensionMultiRel::set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_);
+  }
+  if (detail) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail));
+    if (message_arena != submessage_arena) {
+      detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, detail, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  detail_ = detail;
+  // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionMultiRel.detail)
+}
+
+// -------------------------------------------------------------------
+
+// RelRoot
+
+// .substrait.Rel input = 1;
+inline bool RelRoot::_internal_has_input() const {
+  return this != internal_default_instance() && input_ != nullptr;
+}
+inline bool RelRoot::has_input() const {
+  return _internal_has_input();
+}
+inline void RelRoot::clear_input() {
+  if (GetArenaForAllocation() == nullptr && input_ != nullptr) {
+    delete input_;
+  }
+  input_ = nullptr;
+}
+inline const ::substrait::Rel& RelRoot::_internal_input() const {
+  const ::substrait::Rel* p = input_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Rel&>(
+      ::substrait::_Rel_default_instance_);
+}
+inline const ::substrait::Rel& RelRoot::input() const {
+  // @@protoc_insertion_point(field_get:substrait.RelRoot.input)
+  return _internal_input();
+}
+inline void RelRoot::unsafe_arena_set_allocated_input(
+    ::substrait::Rel* input) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_);
+  }
+  input_ = input;
+  if (input) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelRoot.input)
+}
+inline ::substrait::Rel* RelRoot::release_input() {
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Rel* RelRoot::unsafe_arena_release_input() {
+  // @@protoc_insertion_point(field_release:substrait.RelRoot.input)
+  
+  ::substrait::Rel* temp = input_;
+  input_ = nullptr;
+  return temp;
+}
+inline ::substrait::Rel* RelRoot::_internal_mutable_input() {
+  
+  if (input_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation());
+    input_ = p;
+  }
+  return input_;
+}
+inline ::substrait::Rel* RelRoot::mutable_input() {
+  ::substrait::Rel* _msg = _internal_mutable_input();
+  // @@protoc_insertion_point(field_mutable:substrait.RelRoot.input)
+  return _msg;
+}
+inline void RelRoot::set_allocated_input(::substrait::Rel* input) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete input_;
+  }
+  if (input) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input);
+    if (message_arena != submessage_arena) {
+      input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, input, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  input_ = input;
+  // @@protoc_insertion_point(field_set_allocated:substrait.RelRoot.input)
+}
+
+// repeated string names = 2;
+inline int RelRoot::_internal_names_size() const {
+  return names_.size();
+}
+inline int RelRoot::names_size() const {
+  return _internal_names_size();
+}
+inline void RelRoot::clear_names() {
+  names_.Clear();
+}
+inline std::string* RelRoot::add_names() {
+  std::string* _s = _internal_add_names();
+  // @@protoc_insertion_point(field_add_mutable:substrait.RelRoot.names)
+  return _s;
+}
+inline const std::string& RelRoot::_internal_names(int index) const {
+  return names_.Get(index);
+}
+inline const std::string& RelRoot::names(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.RelRoot.names)
+  return _internal_names(index);
+}
+inline std::string* RelRoot::mutable_names(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.RelRoot.names)
+  return names_.Mutable(index);
+}
+inline void RelRoot::set_names(int index, const std::string& value) {
+  names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.RelRoot.names)
+}
+inline void RelRoot::set_names(int index, std::string&& value) {
+  names_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.RelRoot.names)
+}
+inline void RelRoot::set_names(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.RelRoot.names)
+}
+inline void RelRoot::set_names(int index, const char* value, size_t size) {
+  names_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.RelRoot.names)
+}
+inline std::string* RelRoot::_internal_add_names() {
+  return names_.Add();
+}
+inline void RelRoot::add_names(const std::string& value) {
+  names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.RelRoot.names)
+}
+inline void RelRoot::add_names(std::string&& value) {
+  names_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.RelRoot.names)
+}
+inline void RelRoot::add_names(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.RelRoot.names)
+}
+inline void RelRoot::add_names(const char* value, size_t size) {
+  names_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.RelRoot.names)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+RelRoot::names() const {
+  // @@protoc_insertion_point(field_list:substrait.RelRoot.names)
+  return names_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+RelRoot::mutable_names() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.RelRoot.names)
+  return &names_;
+}
+
+// -------------------------------------------------------------------
+
+// Rel
+
+// .substrait.ReadRel read = 1;
+inline bool Rel::_internal_has_read() const {
+  return rel_type_case() == kRead;
+}
+inline bool Rel::has_read() const {
+  return _internal_has_read();
+}
+inline void Rel::set_has_read() {
+  _oneof_case_[0] = kRead;
+}
+inline void Rel::clear_read() {
+  if (_internal_has_read()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.read_;
+    }
+    clear_has_rel_type();
+  }
+}
+inline ::substrait::ReadRel* Rel::release_read() {
+  // @@protoc_insertion_point(field_release:substrait.Rel.read)
+  if (_internal_has_read()) {
+    clear_has_rel_type();
+      ::substrait::ReadRel* temp = rel_type_.read_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.read_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ReadRel& Rel::_internal_read() const {
+  return _internal_has_read()
+      ? *rel_type_.read_
+      : reinterpret_cast< ::substrait::ReadRel&>(::substrait::_ReadRel_default_instance_);
+}
+inline const ::substrait::ReadRel& Rel::read() const {
+  // @@protoc_insertion_point(field_get:substrait.Rel.read)
+  return _internal_read();
+}
+inline ::substrait::ReadRel* Rel::unsafe_arena_release_read() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.read)
+  if (_internal_has_read()) {
+    clear_has_rel_type();
+    ::substrait::ReadRel* temp = rel_type_.read_;
+    rel_type_.read_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Rel::unsafe_arena_set_allocated_read(::substrait::ReadRel* read) {
+  clear_rel_type();
+  if (read) {
+    set_has_read();
+    rel_type_.read_ = read;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.read)
+}
+inline ::substrait::ReadRel* Rel::_internal_mutable_read() {
+  if (!_internal_has_read()) {
+    clear_rel_type();
+    set_has_read();
+    rel_type_.read_ = CreateMaybeMessage< ::substrait::ReadRel >(GetArenaForAllocation());
+  }
+  return rel_type_.read_;
+}
+inline ::substrait::ReadRel* Rel::mutable_read() {
+  ::substrait::ReadRel* _msg = _internal_mutable_read();
+  // @@protoc_insertion_point(field_mutable:substrait.Rel.read)
+  return _msg;
+}
+
+// .substrait.FilterRel filter = 2;
+inline bool Rel::_internal_has_filter() const {
+  return rel_type_case() == kFilter;
+}
+inline bool Rel::has_filter() const {
+  return _internal_has_filter();
+}
+inline void Rel::set_has_filter() {
+  _oneof_case_[0] = kFilter;
+}
+inline void Rel::clear_filter() {
+  if (_internal_has_filter()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.filter_;
+    }
+    clear_has_rel_type();
+  }
+}
+inline ::substrait::FilterRel* Rel::release_filter() {
+  // @@protoc_insertion_point(field_release:substrait.Rel.filter)
+  if (_internal_has_filter()) {
+    clear_has_rel_type();
+      ::substrait::FilterRel* temp = rel_type_.filter_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.filter_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::FilterRel& Rel::_internal_filter() const {
+  return _internal_has_filter()
+      ? *rel_type_.filter_
+      : reinterpret_cast< ::substrait::FilterRel&>(::substrait::_FilterRel_default_instance_);
+}
+inline const ::substrait::FilterRel& Rel::filter() const {
+  // @@protoc_insertion_point(field_get:substrait.Rel.filter)
+  return _internal_filter();
+}
+inline ::substrait::FilterRel* Rel::unsafe_arena_release_filter() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.filter)
+  if (_internal_has_filter()) {
+    clear_has_rel_type();
+    ::substrait::FilterRel* temp = rel_type_.filter_;
+    rel_type_.filter_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Rel::unsafe_arena_set_allocated_filter(::substrait::FilterRel* filter) {
+  clear_rel_type();
+  if (filter) {
+    set_has_filter();
+    rel_type_.filter_ = filter;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.filter)
+}
+inline ::substrait::FilterRel* Rel::_internal_mutable_filter() {
+  if (!_internal_has_filter()) {
+    clear_rel_type();
+    set_has_filter();
+    rel_type_.filter_ = CreateMaybeMessage< ::substrait::FilterRel >(GetArenaForAllocation());
+  }
+  return rel_type_.filter_;
+}
+inline ::substrait::FilterRel* Rel::mutable_filter() {
+  ::substrait::FilterRel* _msg = _internal_mutable_filter();
+  // @@protoc_insertion_point(field_mutable:substrait.Rel.filter)
+  return _msg;
+}
+
+// .substrait.FetchRel fetch = 3;
+inline bool Rel::_internal_has_fetch() const {
+  return rel_type_case() == kFetch;
+}
+inline bool Rel::has_fetch() const {
+  return _internal_has_fetch();
+}
+inline void Rel::set_has_fetch() {
+  _oneof_case_[0] = kFetch;
+}
+inline void Rel::clear_fetch() {
+  if (_internal_has_fetch()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.fetch_;
+    }
+    clear_has_rel_type();
+  }
+}
+inline ::substrait::FetchRel* Rel::release_fetch() {
+  // @@protoc_insertion_point(field_release:substrait.Rel.fetch)
+  if (_internal_has_fetch()) {
+    clear_has_rel_type();
+      ::substrait::FetchRel* temp = rel_type_.fetch_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.fetch_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::FetchRel& Rel::_internal_fetch() const {
+  return _internal_has_fetch()
+      ? *rel_type_.fetch_
+      : reinterpret_cast< ::substrait::FetchRel&>(::substrait::_FetchRel_default_instance_);
+}
+inline const ::substrait::FetchRel& Rel::fetch() const {
+  // @@protoc_insertion_point(field_get:substrait.Rel.fetch)
+  return _internal_fetch();
+}
+inline ::substrait::FetchRel* Rel::unsafe_arena_release_fetch() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.fetch)
+  if (_internal_has_fetch()) {
+    clear_has_rel_type();
+    ::substrait::FetchRel* temp = rel_type_.fetch_;
+    rel_type_.fetch_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Rel::unsafe_arena_set_allocated_fetch(::substrait::FetchRel* fetch) {
+  clear_rel_type();
+  if (fetch) {
+    set_has_fetch();
+    rel_type_.fetch_ = fetch;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.fetch)
+}
+inline ::substrait::FetchRel* Rel::_internal_mutable_fetch() {
+  if (!_internal_has_fetch()) {
+    clear_rel_type();
+    set_has_fetch();
+    rel_type_.fetch_ = CreateMaybeMessage< ::substrait::FetchRel >(GetArenaForAllocation());
+  }
+  return rel_type_.fetch_;
+}
+inline ::substrait::FetchRel* Rel::mutable_fetch() {
+  ::substrait::FetchRel* _msg = _internal_mutable_fetch();
+  // @@protoc_insertion_point(field_mutable:substrait.Rel.fetch)
+  return _msg;
+}
+
+// .substrait.AggregateRel aggregate = 4;
+inline bool Rel::_internal_has_aggregate() const {
+  return rel_type_case() == kAggregate;
+}
+inline bool Rel::has_aggregate() const {
+  return _internal_has_aggregate();
+}
+inline void Rel::set_has_aggregate() {
+  _oneof_case_[0] = kAggregate;
+}
+inline void Rel::clear_aggregate() {
+  if (_internal_has_aggregate()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.aggregate_;
+    }
+    clear_has_rel_type();
+  }
+}
+inline ::substrait::AggregateRel* Rel::release_aggregate() {
+  // @@protoc_insertion_point(field_release:substrait.Rel.aggregate)
+  if (_internal_has_aggregate()) {
+    clear_has_rel_type();
+      ::substrait::AggregateRel* temp = rel_type_.aggregate_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.aggregate_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::AggregateRel& Rel::_internal_aggregate() const {
+  return _internal_has_aggregate()
+      ? *rel_type_.aggregate_
+      : reinterpret_cast< ::substrait::AggregateRel&>(::substrait::_AggregateRel_default_instance_);
+}
+inline const ::substrait::AggregateRel& Rel::aggregate() const {
+  // @@protoc_insertion_point(field_get:substrait.Rel.aggregate)
+  return _internal_aggregate();
+}
+inline ::substrait::AggregateRel* Rel::unsafe_arena_release_aggregate() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.aggregate)
+  if (_internal_has_aggregate()) {
+    clear_has_rel_type();
+    ::substrait::AggregateRel* temp = rel_type_.aggregate_;
+    rel_type_.aggregate_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Rel::unsafe_arena_set_allocated_aggregate(::substrait::AggregateRel* aggregate) {
+  clear_rel_type();
+  if (aggregate) {
+    set_has_aggregate();
+    rel_type_.aggregate_ = aggregate;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.aggregate)
+}
+inline ::substrait::AggregateRel* Rel::_internal_mutable_aggregate() {
+  if (!_internal_has_aggregate()) {
+    clear_rel_type();
+    set_has_aggregate();
+    rel_type_.aggregate_ = CreateMaybeMessage< ::substrait::AggregateRel >(GetArenaForAllocation());
+  }
+  return rel_type_.aggregate_;
+}
+inline ::substrait::AggregateRel* Rel::mutable_aggregate() {
+  ::substrait::AggregateRel* _msg = _internal_mutable_aggregate();
+  // @@protoc_insertion_point(field_mutable:substrait.Rel.aggregate)
+  return _msg;
+}
+
+// .substrait.SortRel sort = 5;
+inline bool Rel::_internal_has_sort() const {
+  return rel_type_case() == kSort;
+}
+inline bool Rel::has_sort() const {
+  return _internal_has_sort();
+}
+inline void Rel::set_has_sort() {
+  _oneof_case_[0] = kSort;
+}
+inline void Rel::clear_sort() {
+  if (_internal_has_sort()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.sort_;
+    }
+    clear_has_rel_type();
+  }
+}
+inline ::substrait::SortRel* Rel::release_sort() {
+  // @@protoc_insertion_point(field_release:substrait.Rel.sort)
+  if (_internal_has_sort()) {
+    clear_has_rel_type();
+      ::substrait::SortRel* temp = rel_type_.sort_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.sort_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::SortRel& Rel::_internal_sort() const {
+  return _internal_has_sort()
+      ? *rel_type_.sort_
+      : reinterpret_cast< ::substrait::SortRel&>(::substrait::_SortRel_default_instance_);
+}
+inline const ::substrait::SortRel& Rel::sort() const {
+  // @@protoc_insertion_point(field_get:substrait.Rel.sort)
+  return _internal_sort();
+}
+inline ::substrait::SortRel* Rel::unsafe_arena_release_sort() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.sort)
+  if (_internal_has_sort()) {
+    clear_has_rel_type();
+    ::substrait::SortRel* temp = rel_type_.sort_;
+    rel_type_.sort_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Rel::unsafe_arena_set_allocated_sort(::substrait::SortRel* sort) {
+  clear_rel_type();
+  if (sort) {
+    set_has_sort();
+    rel_type_.sort_ = sort;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.sort)
+}
+inline ::substrait::SortRel* Rel::_internal_mutable_sort() {
+  if (!_internal_has_sort()) {
+    clear_rel_type();
+    set_has_sort();
+    rel_type_.sort_ = CreateMaybeMessage< ::substrait::SortRel >(GetArenaForAllocation());
+  }
+  return rel_type_.sort_;
+}
+inline ::substrait::SortRel* Rel::mutable_sort() {
+  ::substrait::SortRel* _msg = _internal_mutable_sort();
+  // @@protoc_insertion_point(field_mutable:substrait.Rel.sort)
+  return _msg;
+}
+
+// .substrait.JoinRel join = 6;
+inline bool Rel::_internal_has_join() const {
+  return rel_type_case() == kJoin;
+}
+inline bool Rel::has_join() const {
+  return _internal_has_join();
+}
+inline void Rel::set_has_join() {
+  _oneof_case_[0] = kJoin;
+}
+inline void Rel::clear_join() {
+  if (_internal_has_join()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.join_;
+    }
+    clear_has_rel_type();
+  }
+}
+inline ::substrait::JoinRel* Rel::release_join() {
+  // @@protoc_insertion_point(field_release:substrait.Rel.join)
+  if (_internal_has_join()) {
+    clear_has_rel_type();
+      ::substrait::JoinRel* temp = rel_type_.join_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.join_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::JoinRel& Rel::_internal_join() const {
+  return _internal_has_join()
+      ? *rel_type_.join_
+      : reinterpret_cast< ::substrait::JoinRel&>(::substrait::_JoinRel_default_instance_);
+}
+inline const ::substrait::JoinRel& Rel::join() const {
+  // @@protoc_insertion_point(field_get:substrait.Rel.join)
+  return _internal_join();
+}
+inline ::substrait::JoinRel* Rel::unsafe_arena_release_join() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.join)
+  if (_internal_has_join()) {
+    clear_has_rel_type();
+    ::substrait::JoinRel* temp = rel_type_.join_;
+    rel_type_.join_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Rel::unsafe_arena_set_allocated_join(::substrait::JoinRel* join) {
+  clear_rel_type();
+  if (join) {
+    set_has_join();
+    rel_type_.join_ = join;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.join)
+}
+inline ::substrait::JoinRel* Rel::_internal_mutable_join() {
+  if (!_internal_has_join()) {
+    clear_rel_type();
+    set_has_join();
+    rel_type_.join_ = CreateMaybeMessage< ::substrait::JoinRel >(GetArenaForAllocation());
+  }
+  return rel_type_.join_;
+}
+inline ::substrait::JoinRel* Rel::mutable_join() {
+  ::substrait::JoinRel* _msg = _internal_mutable_join();
+  // @@protoc_insertion_point(field_mutable:substrait.Rel.join)
+  return _msg;
+}
+
+// .substrait.ProjectRel project = 7;
+inline bool Rel::_internal_has_project() const {
+  return rel_type_case() == kProject;
+}
+inline bool Rel::has_project() const {
+  return _internal_has_project();
+}
+inline void Rel::set_has_project() {
+  _oneof_case_[0] = kProject;
+}
+inline void Rel::clear_project() {
+  if (_internal_has_project()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.project_;
+    }
+    clear_has_rel_type();
+  }
+}
+inline ::substrait::ProjectRel* Rel::release_project() {
+  // @@protoc_insertion_point(field_release:substrait.Rel.project)
+  if (_internal_has_project()) {
+    clear_has_rel_type();
+      ::substrait::ProjectRel* temp = rel_type_.project_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.project_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ProjectRel& Rel::_internal_project() const {
+  return _internal_has_project()
+      ? *rel_type_.project_
+      : reinterpret_cast< ::substrait::ProjectRel&>(::substrait::_ProjectRel_default_instance_);
+}
+inline const ::substrait::ProjectRel& Rel::project() const {
+  // @@protoc_insertion_point(field_get:substrait.Rel.project)
+  return _internal_project();
+}
+inline ::substrait::ProjectRel* Rel::unsafe_arena_release_project() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.project)
+  if (_internal_has_project()) {
+    clear_has_rel_type();
+    ::substrait::ProjectRel* temp = rel_type_.project_;
+    rel_type_.project_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Rel::unsafe_arena_set_allocated_project(::substrait::ProjectRel* project) {
+  clear_rel_type();
+  if (project) {
+    set_has_project();
+    rel_type_.project_ = project;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.project)
+}
+inline ::substrait::ProjectRel* Rel::_internal_mutable_project() {
+  if (!_internal_has_project()) {
+    clear_rel_type();
+    set_has_project();
+    rel_type_.project_ = CreateMaybeMessage< ::substrait::ProjectRel >(GetArenaForAllocation());
+  }
+  return rel_type_.project_;
+}
+inline ::substrait::ProjectRel* Rel::mutable_project() {
+  ::substrait::ProjectRel* _msg = _internal_mutable_project();
+  // @@protoc_insertion_point(field_mutable:substrait.Rel.project)
+  return _msg;
+}
+
+// .substrait.SetRel set = 8;
+inline bool Rel::_internal_has_set() const {
+  return rel_type_case() == kSet;
+}
+inline bool Rel::has_set() const {
+  return _internal_has_set();
+}
+inline void Rel::set_has_set() {
+  _oneof_case_[0] = kSet;
+}
+inline void Rel::clear_set() {
+  if (_internal_has_set()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.set_;
+    }
+    clear_has_rel_type();
+  }
+}
+inline ::substrait::SetRel* Rel::release_set() {
+  // @@protoc_insertion_point(field_release:substrait.Rel.set)
+  if (_internal_has_set()) {
+    clear_has_rel_type();
+      ::substrait::SetRel* temp = rel_type_.set_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.set_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::SetRel& Rel::_internal_set() const {
+  return _internal_has_set()
+      ? *rel_type_.set_
+      : reinterpret_cast< ::substrait::SetRel&>(::substrait::_SetRel_default_instance_);
+}
+inline const ::substrait::SetRel& Rel::set() const {
+  // @@protoc_insertion_point(field_get:substrait.Rel.set)
+  return _internal_set();
+}
+inline ::substrait::SetRel* Rel::unsafe_arena_release_set() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.set)
+  if (_internal_has_set()) {
+    clear_has_rel_type();
+    ::substrait::SetRel* temp = rel_type_.set_;
+    rel_type_.set_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Rel::unsafe_arena_set_allocated_set(::substrait::SetRel* set) {
+  clear_rel_type();
+  if (set) {
+    set_has_set();
+    rel_type_.set_ = set;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.set)
+}
+inline ::substrait::SetRel* Rel::_internal_mutable_set() {
+  if (!_internal_has_set()) {
+    clear_rel_type();
+    set_has_set();
+    rel_type_.set_ = CreateMaybeMessage< ::substrait::SetRel >(GetArenaForAllocation());
+  }
+  return rel_type_.set_;
+}
+inline ::substrait::SetRel* Rel::mutable_set() {
+  ::substrait::SetRel* _msg = _internal_mutable_set();
+  // @@protoc_insertion_point(field_mutable:substrait.Rel.set)
+  return _msg;
+}
+
+// .substrait.ExtensionSingleRel extension_single = 9;
+inline bool Rel::_internal_has_extension_single() const {
+  return rel_type_case() == kExtensionSingle;
+}
+inline bool Rel::has_extension_single() const {
+  return _internal_has_extension_single();
+}
+inline void Rel::set_has_extension_single() {
+  _oneof_case_[0] = kExtensionSingle;
+}
+inline void Rel::clear_extension_single() {
+  if (_internal_has_extension_single()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.extension_single_;
+    }
+    clear_has_rel_type();
+  }
+}
+inline ::substrait::ExtensionSingleRel* Rel::release_extension_single() {
+  // @@protoc_insertion_point(field_release:substrait.Rel.extension_single)
+  if (_internal_has_extension_single()) {
+    clear_has_rel_type();
+      ::substrait::ExtensionSingleRel* temp = rel_type_.extension_single_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.extension_single_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ExtensionSingleRel& Rel::_internal_extension_single() const {
+  return _internal_has_extension_single()
+      ? *rel_type_.extension_single_
+      : reinterpret_cast< ::substrait::ExtensionSingleRel&>(::substrait::_ExtensionSingleRel_default_instance_);
+}
+inline const ::substrait::ExtensionSingleRel& Rel::extension_single() const {
+  // @@protoc_insertion_point(field_get:substrait.Rel.extension_single)
+  return _internal_extension_single();
+}
+inline ::substrait::ExtensionSingleRel* Rel::unsafe_arena_release_extension_single() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.extension_single)
+  if (_internal_has_extension_single()) {
+    clear_has_rel_type();
+    ::substrait::ExtensionSingleRel* temp = rel_type_.extension_single_;
+    rel_type_.extension_single_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Rel::unsafe_arena_set_allocated_extension_single(::substrait::ExtensionSingleRel* extension_single) {
+  clear_rel_type();
+  if (extension_single) {
+    set_has_extension_single();
+    rel_type_.extension_single_ = extension_single;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.extension_single)
+}
+inline ::substrait::ExtensionSingleRel* Rel::_internal_mutable_extension_single() {
+  if (!_internal_has_extension_single()) {
+    clear_rel_type();
+    set_has_extension_single();
+    rel_type_.extension_single_ = CreateMaybeMessage< ::substrait::ExtensionSingleRel >(GetArenaForAllocation());
+  }
+  return rel_type_.extension_single_;
+}
+inline ::substrait::ExtensionSingleRel* Rel::mutable_extension_single() {
+  ::substrait::ExtensionSingleRel* _msg = _internal_mutable_extension_single();
+  // @@protoc_insertion_point(field_mutable:substrait.Rel.extension_single)
+  return _msg;
+}
+
+// .substrait.ExtensionMultiRel extension_multi = 10;
+inline bool Rel::_internal_has_extension_multi() const {
+  return rel_type_case() == kExtensionMulti;
+}
+inline bool Rel::has_extension_multi() const {
+  return _internal_has_extension_multi();
+}
+inline void Rel::set_has_extension_multi() {
+  _oneof_case_[0] = kExtensionMulti;
+}
+inline void Rel::clear_extension_multi() {
+  if (_internal_has_extension_multi()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.extension_multi_;
+    }
+    clear_has_rel_type();
+  }
+}
+inline ::substrait::ExtensionMultiRel* Rel::release_extension_multi() {
+  // @@protoc_insertion_point(field_release:substrait.Rel.extension_multi)
+  if (_internal_has_extension_multi()) {
+    clear_has_rel_type();
+      ::substrait::ExtensionMultiRel* temp = rel_type_.extension_multi_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.extension_multi_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ExtensionMultiRel& Rel::_internal_extension_multi() const {
+  return _internal_has_extension_multi()
+      ? *rel_type_.extension_multi_
+      : reinterpret_cast< ::substrait::ExtensionMultiRel&>(::substrait::_ExtensionMultiRel_default_instance_);
+}
+inline const ::substrait::ExtensionMultiRel& Rel::extension_multi() const {
+  // @@protoc_insertion_point(field_get:substrait.Rel.extension_multi)
+  return _internal_extension_multi();
+}
+inline ::substrait::ExtensionMultiRel* Rel::unsafe_arena_release_extension_multi() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.extension_multi)
+  if (_internal_has_extension_multi()) {
+    clear_has_rel_type();
+    ::substrait::ExtensionMultiRel* temp = rel_type_.extension_multi_;
+    rel_type_.extension_multi_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Rel::unsafe_arena_set_allocated_extension_multi(::substrait::ExtensionMultiRel* extension_multi) {
+  clear_rel_type();
+  if (extension_multi) {
+    set_has_extension_multi();
+    rel_type_.extension_multi_ = extension_multi;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.extension_multi)
+}
+inline ::substrait::ExtensionMultiRel* Rel::_internal_mutable_extension_multi() {
+  if (!_internal_has_extension_multi()) {
+    clear_rel_type();
+    set_has_extension_multi();
+    rel_type_.extension_multi_ = CreateMaybeMessage< ::substrait::ExtensionMultiRel >(GetArenaForAllocation());
+  }
+  return rel_type_.extension_multi_;
+}
+inline ::substrait::ExtensionMultiRel* Rel::mutable_extension_multi() {
+  ::substrait::ExtensionMultiRel* _msg = _internal_mutable_extension_multi();
+  // @@protoc_insertion_point(field_mutable:substrait.Rel.extension_multi)
+  return _msg;
+}
+
+// .substrait.ExtensionLeafRel extension_leaf = 11;
+inline bool Rel::_internal_has_extension_leaf() const {
+  return rel_type_case() == kExtensionLeaf;
+}
+inline bool Rel::has_extension_leaf() const {
+  return _internal_has_extension_leaf();
+}
+inline void Rel::set_has_extension_leaf() {
+  _oneof_case_[0] = kExtensionLeaf;
+}
+inline void Rel::clear_extension_leaf() {
+  if (_internal_has_extension_leaf()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete rel_type_.extension_leaf_;
+    }
+    clear_has_rel_type();
+  }
+}
+inline ::substrait::ExtensionLeafRel* Rel::release_extension_leaf() {
+  // @@protoc_insertion_point(field_release:substrait.Rel.extension_leaf)
+  if (_internal_has_extension_leaf()) {
+    clear_has_rel_type();
+      ::substrait::ExtensionLeafRel* temp = rel_type_.extension_leaf_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    rel_type_.extension_leaf_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::ExtensionLeafRel& Rel::_internal_extension_leaf() const {
+  return _internal_has_extension_leaf()
+      ? *rel_type_.extension_leaf_
+      : reinterpret_cast< ::substrait::ExtensionLeafRel&>(::substrait::_ExtensionLeafRel_default_instance_);
+}
+inline const ::substrait::ExtensionLeafRel& Rel::extension_leaf() const {
+  // @@protoc_insertion_point(field_get:substrait.Rel.extension_leaf)
+  return _internal_extension_leaf();
+}
+inline ::substrait::ExtensionLeafRel* Rel::unsafe_arena_release_extension_leaf() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.extension_leaf)
+  if (_internal_has_extension_leaf()) {
+    clear_has_rel_type();
+    ::substrait::ExtensionLeafRel* temp = rel_type_.extension_leaf_;
+    rel_type_.extension_leaf_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Rel::unsafe_arena_set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_leaf) {
+  clear_rel_type();
+  if (extension_leaf) {
+    set_has_extension_leaf();
+    rel_type_.extension_leaf_ = extension_leaf;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.extension_leaf)
+}
+inline ::substrait::ExtensionLeafRel* Rel::_internal_mutable_extension_leaf() {
+  if (!_internal_has_extension_leaf()) {
+    clear_rel_type();
+    set_has_extension_leaf();
+    rel_type_.extension_leaf_ = CreateMaybeMessage< ::substrait::ExtensionLeafRel >(GetArenaForAllocation());
+  }
+  return rel_type_.extension_leaf_;
+}
+inline ::substrait::ExtensionLeafRel* Rel::mutable_extension_leaf() {
+  ::substrait::ExtensionLeafRel* _msg = _internal_mutable_extension_leaf();
+  // @@protoc_insertion_point(field_mutable:substrait.Rel.extension_leaf)
+  return _msg;
+}
+
+inline bool Rel::has_rel_type() const {
+  return rel_type_case() != REL_TYPE_NOT_SET;
+}
+inline void Rel::clear_has_rel_type() {
+  _oneof_case_[0] = REL_TYPE_NOT_SET;
+}
+inline Rel::RelTypeCase Rel::rel_type_case() const {
+  return Rel::RelTypeCase(_oneof_case_[0]);
+}
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace substrait
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat>() {
+  return ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor();
+}
+template <> struct is_proto_enum< ::substrait::JoinRel_JoinType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::substrait::JoinRel_JoinType>() {
+  return ::substrait::JoinRel_JoinType_descriptor();
+}
+template <> struct is_proto_enum< ::substrait::SetRel_SetOp> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::substrait::SetRel_SetOp>() {
+  return ::substrait::SetRel_SetOp_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2frelations_2eproto
diff --git a/cpp/src/generated/substrait/type.pb.cc b/cpp/src/generated/substrait/type.pb.cc
new file mode 100644
index 000000000000..5bb5b0159413
--- /dev/null
+++ b/cpp/src/generated/substrait/type.pb.cc
@@ -0,0 +1,7858 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/type.proto
+
+#include "substrait/type.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace substrait {
+constexpr Type_Boolean::Type_Boolean(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_BooleanDefaultTypeInternal {
+  constexpr Type_BooleanDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_BooleanDefaultTypeInternal() {}
+  union {
+    Type_Boolean _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_BooleanDefaultTypeInternal _Type_Boolean_default_instance_;
+constexpr Type_I8::Type_I8(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_I8DefaultTypeInternal {
+  constexpr Type_I8DefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_I8DefaultTypeInternal() {}
+  union {
+    Type_I8 _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I8DefaultTypeInternal _Type_I8_default_instance_;
+constexpr Type_I16::Type_I16(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_I16DefaultTypeInternal {
+  constexpr Type_I16DefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_I16DefaultTypeInternal() {}
+  union {
+    Type_I16 _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I16DefaultTypeInternal _Type_I16_default_instance_;
+constexpr Type_I32::Type_I32(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_I32DefaultTypeInternal {
+  constexpr Type_I32DefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_I32DefaultTypeInternal() {}
+  union {
+    Type_I32 _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I32DefaultTypeInternal _Type_I32_default_instance_;
+constexpr Type_I64::Type_I64(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_I64DefaultTypeInternal {
+  constexpr Type_I64DefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_I64DefaultTypeInternal() {}
+  union {
+    Type_I64 _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I64DefaultTypeInternal _Type_I64_default_instance_;
+constexpr Type_FP32::Type_FP32(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_FP32DefaultTypeInternal {
+  constexpr Type_FP32DefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_FP32DefaultTypeInternal() {}
+  union {
+    Type_FP32 _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FP32DefaultTypeInternal _Type_FP32_default_instance_;
+constexpr Type_FP64::Type_FP64(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_FP64DefaultTypeInternal {
+  constexpr Type_FP64DefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_FP64DefaultTypeInternal() {}
+  union {
+    Type_FP64 _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FP64DefaultTypeInternal _Type_FP64_default_instance_;
+constexpr Type_String::Type_String(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_StringDefaultTypeInternal {
+  constexpr Type_StringDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_StringDefaultTypeInternal() {}
+  union {
+    Type_String _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_StringDefaultTypeInternal _Type_String_default_instance_;
+constexpr Type_Binary::Type_Binary(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_BinaryDefaultTypeInternal {
+  constexpr Type_BinaryDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_BinaryDefaultTypeInternal() {}
+  union {
+    Type_Binary _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_BinaryDefaultTypeInternal _Type_Binary_default_instance_;
+constexpr Type_Timestamp::Type_Timestamp(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_TimestampDefaultTypeInternal {
+  constexpr Type_TimestampDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_TimestampDefaultTypeInternal() {}
+  union {
+    Type_Timestamp _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_TimestampDefaultTypeInternal _Type_Timestamp_default_instance_;
+constexpr Type_Date::Type_Date(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_DateDefaultTypeInternal {
+  constexpr Type_DateDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_DateDefaultTypeInternal() {}
+  union {
+    Type_Date _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_DateDefaultTypeInternal _Type_Date_default_instance_;
+constexpr Type_Time::Type_Time(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_TimeDefaultTypeInternal {
+  constexpr Type_TimeDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_TimeDefaultTypeInternal() {}
+  union {
+    Type_Time _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_TimeDefaultTypeInternal _Type_Time_default_instance_;
+constexpr Type_TimestampTZ::Type_TimestampTZ(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_TimestampTZDefaultTypeInternal {
+  constexpr Type_TimestampTZDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_TimestampTZDefaultTypeInternal() {}
+  union {
+    Type_TimestampTZ _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_TimestampTZDefaultTypeInternal _Type_TimestampTZ_default_instance_;
+constexpr Type_IntervalYear::Type_IntervalYear(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_IntervalYearDefaultTypeInternal {
+  constexpr Type_IntervalYearDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_IntervalYearDefaultTypeInternal() {}
+  union {
+    Type_IntervalYear _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_IntervalYearDefaultTypeInternal _Type_IntervalYear_default_instance_;
+constexpr Type_IntervalDay::Type_IntervalDay(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_IntervalDayDefaultTypeInternal {
+  constexpr Type_IntervalDayDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_IntervalDayDefaultTypeInternal() {}
+  union {
+    Type_IntervalDay _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_IntervalDayDefaultTypeInternal _Type_IntervalDay_default_instance_;
+constexpr Type_UUID::Type_UUID(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_UUIDDefaultTypeInternal {
+  constexpr Type_UUIDDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_UUIDDefaultTypeInternal() {}
+  union {
+    Type_UUID _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_UUIDDefaultTypeInternal _Type_UUID_default_instance_;
+constexpr Type_FixedChar::Type_FixedChar(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : length_(0)
+  , type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_FixedCharDefaultTypeInternal {
+  constexpr Type_FixedCharDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_FixedCharDefaultTypeInternal() {}
+  union {
+    Type_FixedChar _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FixedCharDefaultTypeInternal _Type_FixedChar_default_instance_;
+constexpr Type_VarChar::Type_VarChar(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : length_(0)
+  , type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_VarCharDefaultTypeInternal {
+  constexpr Type_VarCharDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_VarCharDefaultTypeInternal() {}
+  union {
+    Type_VarChar _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_VarCharDefaultTypeInternal _Type_VarChar_default_instance_;
+constexpr Type_FixedBinary::Type_FixedBinary(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : length_(0)
+  , type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_FixedBinaryDefaultTypeInternal {
+  constexpr Type_FixedBinaryDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_FixedBinaryDefaultTypeInternal() {}
+  union {
+    Type_FixedBinary _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FixedBinaryDefaultTypeInternal _Type_FixedBinary_default_instance_;
+constexpr Type_Decimal::Type_Decimal(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : scale_(0)
+  , precision_(0)
+  , type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_DecimalDefaultTypeInternal {
+  constexpr Type_DecimalDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_DecimalDefaultTypeInternal() {}
+  union {
+    Type_Decimal _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_DecimalDefaultTypeInternal _Type_Decimal_default_instance_;
+constexpr Type_Struct::Type_Struct(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : types_()
+  , type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_StructDefaultTypeInternal {
+  constexpr Type_StructDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_StructDefaultTypeInternal() {}
+  union {
+    Type_Struct _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_StructDefaultTypeInternal _Type_Struct_default_instance_;
+constexpr Type_List::Type_List(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_(nullptr)
+  , type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_ListDefaultTypeInternal {
+  constexpr Type_ListDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_ListDefaultTypeInternal() {}
+  union {
+    Type_List _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_ListDefaultTypeInternal _Type_List_default_instance_;
+constexpr Type_Map::Type_Map(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : key_(nullptr)
+  , value_(nullptr)
+  , type_variation_reference_(0u)
+  , nullability_(0)
+{}
+struct Type_MapDefaultTypeInternal {
+  constexpr Type_MapDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~Type_MapDefaultTypeInternal() {}
+  union {
+    Type_Map _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_MapDefaultTypeInternal _Type_Map_default_instance_;
+constexpr Type::Type(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct TypeDefaultTypeInternal {
+  constexpr TypeDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~TypeDefaultTypeInternal() {}
+  union {
+    Type _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TypeDefaultTypeInternal _Type_default_instance_;
+constexpr NamedStruct::NamedStruct(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : names_()
+  , struct__(nullptr){}
+struct NamedStructDefaultTypeInternal {
+  constexpr NamedStructDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~NamedStructDefaultTypeInternal() {}
+  union {
+    NamedStruct _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NamedStructDefaultTypeInternal _NamedStruct_default_instance_;
+}  // namespace substrait
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ftype_2eproto[25];
+static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ftype_2eproto[1];
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ftype_2eproto = nullptr;
+
+const uint32_t TableStruct_substrait_2ftype_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Boolean, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Boolean, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Boolean, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_I8, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_I8, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_I8, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_I16, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_I16, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_I16, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_I32, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_I32, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_I32, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_I64, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_I64, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_I64, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FP32, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FP32, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FP32, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FP64, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FP64, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FP64, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_String, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_String, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_String, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Binary, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Binary, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Binary, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Timestamp, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Timestamp, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Timestamp, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Date, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Date, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Date, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Time, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Time, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Time, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_TimestampTZ, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_TimestampTZ, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_TimestampTZ, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalYear, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalYear, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalYear, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalDay, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalDay, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalDay, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_UUID, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_UUID, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_UUID, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, length_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, length_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, length_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, scale_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, precision_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, types_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_List, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_List, type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_List, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_List, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, key_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, value_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, type_variation_reference_),
+  PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::Type, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::Type, kind_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::NamedStruct, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::NamedStruct, names_),
+  PROTOBUF_FIELD_OFFSET(::substrait::NamedStruct, struct__),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, -1, sizeof(::substrait::Type_Boolean)},
+  { 8, -1, -1, sizeof(::substrait::Type_I8)},
+  { 16, -1, -1, sizeof(::substrait::Type_I16)},
+  { 24, -1, -1, sizeof(::substrait::Type_I32)},
+  { 32, -1, -1, sizeof(::substrait::Type_I64)},
+  { 40, -1, -1, sizeof(::substrait::Type_FP32)},
+  { 48, -1, -1, sizeof(::substrait::Type_FP64)},
+  { 56, -1, -1, sizeof(::substrait::Type_String)},
+  { 64, -1, -1, sizeof(::substrait::Type_Binary)},
+  { 72, -1, -1, sizeof(::substrait::Type_Timestamp)},
+  { 80, -1, -1, sizeof(::substrait::Type_Date)},
+  { 88, -1, -1, sizeof(::substrait::Type_Time)},
+  { 96, -1, -1, sizeof(::substrait::Type_TimestampTZ)},
+  { 104, -1, -1, sizeof(::substrait::Type_IntervalYear)},
+  { 112, -1, -1, sizeof(::substrait::Type_IntervalDay)},
+  { 120, -1, -1, sizeof(::substrait::Type_UUID)},
+  { 128, -1, -1, sizeof(::substrait::Type_FixedChar)},
+  { 137, -1, -1, sizeof(::substrait::Type_VarChar)},
+  { 146, -1, -1, sizeof(::substrait::Type_FixedBinary)},
+  { 155, -1, -1, sizeof(::substrait::Type_Decimal)},
+  { 165, -1, -1, sizeof(::substrait::Type_Struct)},
+  { 174, -1, -1, sizeof(::substrait::Type_List)},
+  { 183, -1, -1, sizeof(::substrait::Type_Map)},
+  { 193, -1, -1, sizeof(::substrait::Type)},
+  { 224, -1, -1, sizeof(::substrait::NamedStruct)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_Boolean_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_I8_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_I16_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_I32_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_I64_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_FP32_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_FP64_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_String_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_Binary_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_Timestamp_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_Date_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_Time_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_TimestampTZ_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_IntervalYear_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_IntervalDay_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_UUID_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_FixedChar_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_VarChar_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_FixedBinary_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_Decimal_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_Struct_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_List_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_Map_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_Type_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_NamedStruct_default_instance_),
+};
+
+const char descriptor_table_protodef_substrait_2ftype_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\024substrait/type.proto\022\tsubstrait\"\245\033\n\004Ty"
+  "pe\022\'\n\004bool\030\001 \001(\0132\027.substrait.Type.Boolea"
+  "nH\000\022 \n\002i8\030\002 \001(\0132\022.substrait.Type.I8H\000\022\"\n"
+  "\003i16\030\003 \001(\0132\023.substrait.Type.I16H\000\022\"\n\003i32"
+  "\030\005 \001(\0132\023.substrait.Type.I32H\000\022\"\n\003i64\030\007 \001"
+  "(\0132\023.substrait.Type.I64H\000\022$\n\004fp32\030\n \001(\0132"
+  "\024.substrait.Type.FP32H\000\022$\n\004fp64\030\013 \001(\0132\024."
+  "substrait.Type.FP64H\000\022(\n\006string\030\014 \001(\0132\026."
+  "substrait.Type.StringH\000\022(\n\006binary\030\r \001(\0132"
+  "\026.substrait.Type.BinaryH\000\022.\n\ttimestamp\030\016"
+  " \001(\0132\031.substrait.Type.TimestampH\000\022$\n\004dat"
+  "e\030\020 \001(\0132\024.substrait.Type.DateH\000\022$\n\004time\030"
+  "\021 \001(\0132\024.substrait.Type.TimeH\000\0225\n\rinterva"
+  "l_year\030\023 \001(\0132\034.substrait.Type.IntervalYe"
+  "arH\000\0223\n\014interval_day\030\024 \001(\0132\033.substrait.T"
+  "ype.IntervalDayH\000\0223\n\014timestamp_tz\030\035 \001(\0132"
+  "\033.substrait.Type.TimestampTZH\000\022$\n\004uuid\030 "
+  " \001(\0132\024.substrait.Type.UUIDH\000\022/\n\nfixed_ch"
+  "ar\030\025 \001(\0132\031.substrait.Type.FixedCharH\000\022*\n"
+  "\007varchar\030\026 \001(\0132\027.substrait.Type.VarCharH"
+  "\000\0223\n\014fixed_binary\030\027 \001(\0132\033.substrait.Type"
+  ".FixedBinaryH\000\022*\n\007decimal\030\030 \001(\0132\027.substr"
+  "ait.Type.DecimalH\000\022(\n\006struct\030\031 \001(\0132\026.sub"
+  "strait.Type.StructH\000\022$\n\004list\030\033 \001(\0132\024.sub"
+  "strait.Type.ListH\000\022\"\n\003map\030\034 \001(\0132\023.substr"
+  "ait.Type.MapH\000\022%\n\033user_defined_type_refe"
+  "rence\030\037 \001(\rH\000\032]\n\007Boolean\022 \n\030type_variati"
+  "on_reference\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162"
+  "\033.substrait.Type.Nullability\032X\n\002I8\022 \n\030ty"
+  "pe_variation_reference\030\001 \001(\r\0220\n\013nullabil"
+  "ity\030\002 \001(\0162\033.substrait.Type.Nullability\032Y"
+  "\n\003I16\022 \n\030type_variation_reference\030\001 \001(\r\022"
+  "0\n\013nullability\030\002 \001(\0162\033.substrait.Type.Nu"
+  "llability\032Y\n\003I32\022 \n\030type_variation_refer"
+  "ence\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.substr"
+  "ait.Type.Nullability\032Y\n\003I64\022 \n\030type_vari"
+  "ation_reference\030\001 \001(\r\0220\n\013nullability\030\002 \001"
+  "(\0162\033.substrait.Type.Nullability\032Z\n\004FP32\022"
+  " \n\030type_variation_reference\030\001 \001(\r\0220\n\013nul"
+  "lability\030\002 \001(\0162\033.substrait.Type.Nullabil"
+  "ity\032Z\n\004FP64\022 \n\030type_variation_reference\030"
+  "\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.substrait.T"
+  "ype.Nullability\032\\\n\006String\022 \n\030type_variat"
+  "ion_reference\030\001 \001(\r\0220\n\013nullability\030\002 \001(\016"
+  "2\033.substrait.Type.Nullability\032\\\n\006Binary\022"
+  " \n\030type_variation_reference\030\001 \001(\r\0220\n\013nul"
+  "lability\030\002 \001(\0162\033.substrait.Type.Nullabil"
+  "ity\032_\n\tTimestamp\022 \n\030type_variation_refer"
+  "ence\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.substr"
+  "ait.Type.Nullability\032Z\n\004Date\022 \n\030type_var"
+  "iation_reference\030\001 \001(\r\0220\n\013nullability\030\002 "
+  "\001(\0162\033.substrait.Type.Nullability\032Z\n\004Time"
+  "\022 \n\030type_variation_reference\030\001 \001(\r\0220\n\013nu"
+  "llability\030\002 \001(\0162\033.substrait.Type.Nullabi"
+  "lity\032a\n\013TimestampTZ\022 \n\030type_variation_re"
+  "ference\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.sub"
+  "strait.Type.Nullability\032b\n\014IntervalYear\022"
+  " \n\030type_variation_reference\030\001 \001(\r\0220\n\013nul"
+  "lability\030\002 \001(\0162\033.substrait.Type.Nullabil"
+  "ity\032a\n\013IntervalDay\022 \n\030type_variation_ref"
+  "erence\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.subs"
+  "trait.Type.Nullability\032Z\n\004UUID\022 \n\030type_v"
+  "ariation_reference\030\001 \001(\r\0220\n\013nullability\030"
+  "\002 \001(\0162\033.substrait.Type.Nullability\032o\n\tFi"
+  "xedChar\022\016\n\006length\030\001 \001(\005\022 \n\030type_variatio"
+  "n_reference\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033"
+  ".substrait.Type.Nullability\032m\n\007VarChar\022\016"
+  "\n\006length\030\001 \001(\005\022 \n\030type_variation_referen"
+  "ce\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033.substrai"
+  "t.Type.Nullability\032q\n\013FixedBinary\022\016\n\006len"
+  "gth\030\001 \001(\005\022 \n\030type_variation_reference\030\002 "
+  "\001(\r\0220\n\013nullability\030\003 \001(\0162\033.substrait.Typ"
+  "e.Nullability\032\177\n\007Decimal\022\r\n\005scale\030\001 \001(\005\022"
+  "\021\n\tprecision\030\002 \001(\005\022 \n\030type_variation_ref"
+  "erence\030\003 \001(\r\0220\n\013nullability\030\004 \001(\0162\033.subs"
+  "trait.Type.Nullability\032|\n\006Struct\022\036\n\005type"
+  "s\030\001 \003(\0132\017.substrait.Type\022 \n\030type_variati"
+  "on_reference\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162"
+  "\033.substrait.Type.Nullability\032y\n\004List\022\035\n\004"
+  "type\030\001 \001(\0132\017.substrait.Type\022 \n\030type_vari"
+  "ation_reference\030\002 \001(\r\0220\n\013nullability\030\003 \001"
+  "(\0162\033.substrait.Type.Nullability\032\227\001\n\003Map\022"
+  "\034\n\003key\030\001 \001(\0132\017.substrait.Type\022\036\n\005value\030\002"
+  " \001(\0132\017.substrait.Type\022 \n\030type_variation_"
+  "reference\030\003 \001(\r\0220\n\013nullability\030\004 \001(\0162\033.s"
+  "ubstrait.Type.Nullability\"^\n\013Nullability"
+  "\022\033\n\027NULLABILITY_UNSPECIFIED\020\000\022\030\n\024NULLABI"
+  "LITY_NULLABLE\020\001\022\030\n\024NULLABILITY_REQUIRED\020"
+  "\002B\006\n\004kind\"D\n\013NamedStruct\022\r\n\005names\030\001 \003(\t\022"
+  "&\n\006struct\030\002 \001(\0132\026.substrait.Type.StructB"
+  "+\n\022io.substrait.protoP\001\252\002\022Substrait.Prot"
+  "obufb\006proto3"
+  ;
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2ftype_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_2eproto = {
+  false, false, 3652, descriptor_table_protodef_substrait_2ftype_2eproto, "substrait/type.proto", 
+  &descriptor_table_substrait_2ftype_2eproto_once, nullptr, 0, 25,
+  schemas, file_default_instances, TableStruct_substrait_2ftype_2eproto::offsets,
+  file_level_metadata_substrait_2ftype_2eproto, file_level_enum_descriptors_substrait_2ftype_2eproto, file_level_service_descriptors_substrait_2ftype_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2ftype_2eproto_getter() {
+  return &descriptor_table_substrait_2ftype_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2ftype_2eproto(&descriptor_table_substrait_2ftype_2eproto);
+namespace substrait {
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_Nullability_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ftype_2eproto);
+  return file_level_enum_descriptors_substrait_2ftype_2eproto[0];
+}
+bool Type_Nullability_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr Type_Nullability Type::NULLABILITY_UNSPECIFIED;
+constexpr Type_Nullability Type::NULLABILITY_NULLABLE;
+constexpr Type_Nullability Type::NULLABILITY_REQUIRED;
+constexpr Type_Nullability Type::Nullability_MIN;
+constexpr Type_Nullability Type::Nullability_MAX;
+constexpr int Type::Nullability_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+
+// ===================================================================
+
+class Type_Boolean::_Internal {
+ public:
+};
+
+Type_Boolean::Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.Boolean)
+}
+Type_Boolean::Type_Boolean(const Type_Boolean& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.Boolean)
+}
+
+inline void Type_Boolean::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_Boolean::~Type_Boolean() {
+  // @@protoc_insertion_point(destructor:substrait.Type.Boolean)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_Boolean::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_Boolean::ArenaDtor(void* object) {
+  Type_Boolean* _this = reinterpret_cast< Type_Boolean* >(object);
+  (void)_this;
+}
+void Type_Boolean::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_Boolean::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_Boolean::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.Boolean)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_Boolean::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_Boolean::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Boolean)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Boolean)
+  return target;
+}
+
+size_t Type_Boolean::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Boolean)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Boolean::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_Boolean::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Boolean::GetClassData() const { return &_class_data_; }
+
+void Type_Boolean::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_Boolean *>(to)->MergeFrom(
+      static_cast<const Type_Boolean &>(from));
+}
+
+
+void Type_Boolean::MergeFrom(const Type_Boolean& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Boolean)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_Boolean::CopyFrom(const Type_Boolean& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Boolean)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_Boolean::IsInitialized() const {
+  return true;
+}
+
+void Type_Boolean::InternalSwap(Type_Boolean* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_Boolean, nullability_)
+      + sizeof(Type_Boolean::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_Boolean, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_Boolean::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[0]);
+}
+
+// ===================================================================
+
+class Type_I8::_Internal {
+ public:
+};
+
+Type_I8::Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.I8)
+}
+Type_I8::Type_I8(const Type_I8& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.I8)
+}
+
+inline void Type_I8::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_I8::~Type_I8() {
+  // @@protoc_insertion_point(destructor:substrait.Type.I8)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_I8::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_I8::ArenaDtor(void* object) {
+  Type_I8* _this = reinterpret_cast< Type_I8* >(object);
+  (void)_this;
+}
+void Type_I8::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_I8::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_I8::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.I8)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_I8::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_I8::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I8)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.I8)
+  return target;
+}
+
+size_t Type_I8::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.I8)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_I8::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_I8::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_I8::GetClassData() const { return &_class_data_; }
+
+void Type_I8::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_I8 *>(to)->MergeFrom(
+      static_cast<const Type_I8 &>(from));
+}
+
+
+void Type_I8::MergeFrom(const Type_I8& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I8)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_I8::CopyFrom(const Type_I8& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.I8)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_I8::IsInitialized() const {
+  return true;
+}
+
+void Type_I8::InternalSwap(Type_I8* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_I8, nullability_)
+      + sizeof(Type_I8::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_I8, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_I8::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[1]);
+}
+
+// ===================================================================
+
+class Type_I16::_Internal {
+ public:
+};
+
+Type_I16::Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.I16)
+}
+Type_I16::Type_I16(const Type_I16& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.I16)
+}
+
+inline void Type_I16::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_I16::~Type_I16() {
+  // @@protoc_insertion_point(destructor:substrait.Type.I16)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_I16::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_I16::ArenaDtor(void* object) {
+  Type_I16* _this = reinterpret_cast< Type_I16* >(object);
+  (void)_this;
+}
+void Type_I16::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_I16::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_I16::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.I16)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_I16::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_I16::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I16)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.I16)
+  return target;
+}
+
+size_t Type_I16::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.I16)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_I16::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_I16::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_I16::GetClassData() const { return &_class_data_; }
+
+void Type_I16::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_I16 *>(to)->MergeFrom(
+      static_cast<const Type_I16 &>(from));
+}
+
+
+void Type_I16::MergeFrom(const Type_I16& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I16)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_I16::CopyFrom(const Type_I16& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.I16)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_I16::IsInitialized() const {
+  return true;
+}
+
+void Type_I16::InternalSwap(Type_I16* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_I16, nullability_)
+      + sizeof(Type_I16::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_I16, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_I16::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[2]);
+}
+
+// ===================================================================
+
+class Type_I32::_Internal {
+ public:
+};
+
+Type_I32::Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.I32)
+}
+Type_I32::Type_I32(const Type_I32& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.I32)
+}
+
+inline void Type_I32::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_I32::~Type_I32() {
+  // @@protoc_insertion_point(destructor:substrait.Type.I32)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_I32::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_I32::ArenaDtor(void* object) {
+  Type_I32* _this = reinterpret_cast< Type_I32* >(object);
+  (void)_this;
+}
+void Type_I32::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_I32::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_I32::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.I32)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_I32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_I32::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I32)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.I32)
+  return target;
+}
+
+size_t Type_I32::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.I32)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_I32::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_I32::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_I32::GetClassData() const { return &_class_data_; }
+
+void Type_I32::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_I32 *>(to)->MergeFrom(
+      static_cast<const Type_I32 &>(from));
+}
+
+
+void Type_I32::MergeFrom(const Type_I32& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I32)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_I32::CopyFrom(const Type_I32& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.I32)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_I32::IsInitialized() const {
+  return true;
+}
+
+void Type_I32::InternalSwap(Type_I32* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_I32, nullability_)
+      + sizeof(Type_I32::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_I32, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_I32::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[3]);
+}
+
+// ===================================================================
+
+class Type_I64::_Internal {
+ public:
+};
+
+Type_I64::Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.I64)
+}
+Type_I64::Type_I64(const Type_I64& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.I64)
+}
+
+inline void Type_I64::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_I64::~Type_I64() {
+  // @@protoc_insertion_point(destructor:substrait.Type.I64)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_I64::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_I64::ArenaDtor(void* object) {
+  Type_I64* _this = reinterpret_cast< Type_I64* >(object);
+  (void)_this;
+}
+void Type_I64::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_I64::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_I64::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.I64)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_I64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_I64::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I64)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.I64)
+  return target;
+}
+
+size_t Type_I64::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.I64)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_I64::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_I64::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_I64::GetClassData() const { return &_class_data_; }
+
+void Type_I64::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_I64 *>(to)->MergeFrom(
+      static_cast<const Type_I64 &>(from));
+}
+
+
+void Type_I64::MergeFrom(const Type_I64& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I64)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_I64::CopyFrom(const Type_I64& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.I64)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_I64::IsInitialized() const {
+  return true;
+}
+
+void Type_I64::InternalSwap(Type_I64* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_I64, nullability_)
+      + sizeof(Type_I64::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_I64, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_I64::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[4]);
+}
+
+// ===================================================================
+
+class Type_FP32::_Internal {
+ public:
+};
+
+Type_FP32::Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.FP32)
+}
+Type_FP32::Type_FP32(const Type_FP32& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.FP32)
+}
+
+inline void Type_FP32::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_FP32::~Type_FP32() {
+  // @@protoc_insertion_point(destructor:substrait.Type.FP32)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_FP32::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_FP32::ArenaDtor(void* object) {
+  Type_FP32* _this = reinterpret_cast< Type_FP32* >(object);
+  (void)_this;
+}
+void Type_FP32::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_FP32::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_FP32::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.FP32)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_FP32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_FP32::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FP32)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.FP32)
+  return target;
+}
+
+size_t Type_FP32::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.FP32)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_FP32::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_FP32::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_FP32::GetClassData() const { return &_class_data_; }
+
+void Type_FP32::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_FP32 *>(to)->MergeFrom(
+      static_cast<const Type_FP32 &>(from));
+}
+
+
+void Type_FP32::MergeFrom(const Type_FP32& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FP32)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_FP32::CopyFrom(const Type_FP32& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.FP32)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_FP32::IsInitialized() const {
+  return true;
+}
+
+void Type_FP32::InternalSwap(Type_FP32* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_FP32, nullability_)
+      + sizeof(Type_FP32::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_FP32, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_FP32::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[5]);
+}
+
+// ===================================================================
+
+class Type_FP64::_Internal {
+ public:
+};
+
+Type_FP64::Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.FP64)
+}
+Type_FP64::Type_FP64(const Type_FP64& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.FP64)
+}
+
+inline void Type_FP64::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_FP64::~Type_FP64() {
+  // @@protoc_insertion_point(destructor:substrait.Type.FP64)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_FP64::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_FP64::ArenaDtor(void* object) {
+  Type_FP64* _this = reinterpret_cast< Type_FP64* >(object);
+  (void)_this;
+}
+void Type_FP64::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_FP64::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_FP64::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.FP64)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_FP64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_FP64::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FP64)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.FP64)
+  return target;
+}
+
+size_t Type_FP64::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.FP64)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_FP64::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_FP64::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_FP64::GetClassData() const { return &_class_data_; }
+
+void Type_FP64::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_FP64 *>(to)->MergeFrom(
+      static_cast<const Type_FP64 &>(from));
+}
+
+
+void Type_FP64::MergeFrom(const Type_FP64& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FP64)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_FP64::CopyFrom(const Type_FP64& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.FP64)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_FP64::IsInitialized() const {
+  return true;
+}
+
+void Type_FP64::InternalSwap(Type_FP64* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_FP64, nullability_)
+      + sizeof(Type_FP64::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_FP64, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_FP64::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[6]);
+}
+
+// ===================================================================
+
+class Type_String::_Internal {
+ public:
+};
+
+Type_String::Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.String)
+}
+Type_String::Type_String(const Type_String& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.String)
+}
+
+inline void Type_String::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_String::~Type_String() {
+  // @@protoc_insertion_point(destructor:substrait.Type.String)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_String::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_String::ArenaDtor(void* object) {
+  Type_String* _this = reinterpret_cast< Type_String* >(object);
+  (void)_this;
+}
+void Type_String::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_String::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_String::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.String)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_String::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_String::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.String)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.String)
+  return target;
+}
+
+size_t Type_String::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.String)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_String::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_String::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_String::GetClassData() const { return &_class_data_; }
+
+void Type_String::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_String *>(to)->MergeFrom(
+      static_cast<const Type_String &>(from));
+}
+
+
+void Type_String::MergeFrom(const Type_String& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.String)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_String::CopyFrom(const Type_String& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.String)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_String::IsInitialized() const {
+  return true;
+}
+
+void Type_String::InternalSwap(Type_String* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_String, nullability_)
+      + sizeof(Type_String::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_String, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_String::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[7]);
+}
+
+// ===================================================================
+
+class Type_Binary::_Internal {
+ public:
+};
+
+Type_Binary::Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.Binary)
+}
+Type_Binary::Type_Binary(const Type_Binary& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.Binary)
+}
+
+inline void Type_Binary::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_Binary::~Type_Binary() {
+  // @@protoc_insertion_point(destructor:substrait.Type.Binary)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_Binary::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_Binary::ArenaDtor(void* object) {
+  Type_Binary* _this = reinterpret_cast< Type_Binary* >(object);
+  (void)_this;
+}
+void Type_Binary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_Binary::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_Binary::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.Binary)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_Binary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_Binary::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Binary)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Binary)
+  return target;
+}
+
+size_t Type_Binary::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Binary)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Binary::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_Binary::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Binary::GetClassData() const { return &_class_data_; }
+
+void Type_Binary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_Binary *>(to)->MergeFrom(
+      static_cast<const Type_Binary &>(from));
+}
+
+
+void Type_Binary::MergeFrom(const Type_Binary& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Binary)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_Binary::CopyFrom(const Type_Binary& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Binary)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_Binary::IsInitialized() const {
+  return true;
+}
+
+void Type_Binary::InternalSwap(Type_Binary* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_Binary, nullability_)
+      + sizeof(Type_Binary::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_Binary, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_Binary::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[8]);
+}
+
+// ===================================================================
+
+class Type_Timestamp::_Internal {
+ public:
+};
+
+Type_Timestamp::Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.Timestamp)
+}
+Type_Timestamp::Type_Timestamp(const Type_Timestamp& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.Timestamp)
+}
+
+inline void Type_Timestamp::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_Timestamp::~Type_Timestamp() {
+  // @@protoc_insertion_point(destructor:substrait.Type.Timestamp)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_Timestamp::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_Timestamp::ArenaDtor(void* object) {
+  Type_Timestamp* _this = reinterpret_cast< Type_Timestamp* >(object);
+  (void)_this;
+}
+void Type_Timestamp::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_Timestamp::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_Timestamp::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.Timestamp)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_Timestamp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_Timestamp::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Timestamp)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Timestamp)
+  return target;
+}
+
+size_t Type_Timestamp::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Timestamp)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Timestamp::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_Timestamp::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Timestamp::GetClassData() const { return &_class_data_; }
+
+void Type_Timestamp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_Timestamp *>(to)->MergeFrom(
+      static_cast<const Type_Timestamp &>(from));
+}
+
+
+void Type_Timestamp::MergeFrom(const Type_Timestamp& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Timestamp)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_Timestamp::CopyFrom(const Type_Timestamp& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Timestamp)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_Timestamp::IsInitialized() const {
+  return true;
+}
+
+void Type_Timestamp::InternalSwap(Type_Timestamp* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_Timestamp, nullability_)
+      + sizeof(Type_Timestamp::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_Timestamp, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_Timestamp::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[9]);
+}
+
+// ===================================================================
+
+class Type_Date::_Internal {
+ public:
+};
+
+Type_Date::Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.Date)
+}
+Type_Date::Type_Date(const Type_Date& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.Date)
+}
+
+inline void Type_Date::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_Date::~Type_Date() {
+  // @@protoc_insertion_point(destructor:substrait.Type.Date)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_Date::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_Date::ArenaDtor(void* object) {
+  Type_Date* _this = reinterpret_cast< Type_Date* >(object);
+  (void)_this;
+}
+void Type_Date::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_Date::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_Date::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.Date)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_Date::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_Date::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Date)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Date)
+  return target;
+}
+
+size_t Type_Date::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Date)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Date::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_Date::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Date::GetClassData() const { return &_class_data_; }
+
+void Type_Date::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_Date *>(to)->MergeFrom(
+      static_cast<const Type_Date &>(from));
+}
+
+
+void Type_Date::MergeFrom(const Type_Date& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Date)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_Date::CopyFrom(const Type_Date& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Date)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_Date::IsInitialized() const {
+  return true;
+}
+
+void Type_Date::InternalSwap(Type_Date* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_Date, nullability_)
+      + sizeof(Type_Date::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_Date, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_Date::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[10]);
+}
+
+// ===================================================================
+
+class Type_Time::_Internal {
+ public:
+};
+
+Type_Time::Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.Time)
+}
+Type_Time::Type_Time(const Type_Time& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.Time)
+}
+
+inline void Type_Time::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_Time::~Type_Time() {
+  // @@protoc_insertion_point(destructor:substrait.Type.Time)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_Time::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_Time::ArenaDtor(void* object) {
+  Type_Time* _this = reinterpret_cast< Type_Time* >(object);
+  (void)_this;
+}
+void Type_Time::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_Time::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_Time::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.Time)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_Time::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_Time::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Time)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Time)
+  return target;
+}
+
+size_t Type_Time::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Time)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Time::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_Time::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Time::GetClassData() const { return &_class_data_; }
+
+void Type_Time::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_Time *>(to)->MergeFrom(
+      static_cast<const Type_Time &>(from));
+}
+
+
+void Type_Time::MergeFrom(const Type_Time& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Time)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_Time::CopyFrom(const Type_Time& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Time)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_Time::IsInitialized() const {
+  return true;
+}
+
+void Type_Time::InternalSwap(Type_Time* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_Time, nullability_)
+      + sizeof(Type_Time::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_Time, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_Time::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[11]);
+}
+
+// ===================================================================
+
+class Type_TimestampTZ::_Internal {
+ public:
+};
+
+Type_TimestampTZ::Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.TimestampTZ)
+}
+Type_TimestampTZ::Type_TimestampTZ(const Type_TimestampTZ& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.TimestampTZ)
+}
+
+inline void Type_TimestampTZ::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_TimestampTZ::~Type_TimestampTZ() {
+  // @@protoc_insertion_point(destructor:substrait.Type.TimestampTZ)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_TimestampTZ::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_TimestampTZ::ArenaDtor(void* object) {
+  Type_TimestampTZ* _this = reinterpret_cast< Type_TimestampTZ* >(object);
+  (void)_this;
+}
+void Type_TimestampTZ::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_TimestampTZ::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_TimestampTZ::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.TimestampTZ)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_TimestampTZ::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_TimestampTZ::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.TimestampTZ)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.TimestampTZ)
+  return target;
+}
+
+size_t Type_TimestampTZ::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.TimestampTZ)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_TimestampTZ::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_TimestampTZ::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_TimestampTZ::GetClassData() const { return &_class_data_; }
+
+void Type_TimestampTZ::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_TimestampTZ *>(to)->MergeFrom(
+      static_cast<const Type_TimestampTZ &>(from));
+}
+
+
+void Type_TimestampTZ::MergeFrom(const Type_TimestampTZ& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.TimestampTZ)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_TimestampTZ::CopyFrom(const Type_TimestampTZ& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.TimestampTZ)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_TimestampTZ::IsInitialized() const {
+  return true;
+}
+
+void Type_TimestampTZ::InternalSwap(Type_TimestampTZ* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_TimestampTZ, nullability_)
+      + sizeof(Type_TimestampTZ::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_TimestampTZ, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_TimestampTZ::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[12]);
+}
+
+// ===================================================================
+
+class Type_IntervalYear::_Internal {
+ public:
+};
+
+Type_IntervalYear::Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.IntervalYear)
+}
+Type_IntervalYear::Type_IntervalYear(const Type_IntervalYear& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.IntervalYear)
+}
+
+inline void Type_IntervalYear::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_IntervalYear::~Type_IntervalYear() {
+  // @@protoc_insertion_point(destructor:substrait.Type.IntervalYear)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_IntervalYear::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_IntervalYear::ArenaDtor(void* object) {
+  Type_IntervalYear* _this = reinterpret_cast< Type_IntervalYear* >(object);
+  (void)_this;
+}
+void Type_IntervalYear::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_IntervalYear::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_IntervalYear::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.IntervalYear)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_IntervalYear::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_IntervalYear::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.IntervalYear)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.IntervalYear)
+  return target;
+}
+
+size_t Type_IntervalYear::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.IntervalYear)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_IntervalYear::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_IntervalYear::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_IntervalYear::GetClassData() const { return &_class_data_; }
+
+void Type_IntervalYear::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_IntervalYear *>(to)->MergeFrom(
+      static_cast<const Type_IntervalYear &>(from));
+}
+
+
+void Type_IntervalYear::MergeFrom(const Type_IntervalYear& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.IntervalYear)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_IntervalYear::CopyFrom(const Type_IntervalYear& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.IntervalYear)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_IntervalYear::IsInitialized() const {
+  return true;
+}
+
+void Type_IntervalYear::InternalSwap(Type_IntervalYear* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_IntervalYear, nullability_)
+      + sizeof(Type_IntervalYear::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_IntervalYear, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_IntervalYear::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[13]);
+}
+
+// ===================================================================
+
+class Type_IntervalDay::_Internal {
+ public:
+};
+
+Type_IntervalDay::Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.IntervalDay)
+}
+Type_IntervalDay::Type_IntervalDay(const Type_IntervalDay& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.IntervalDay)
+}
+
+inline void Type_IntervalDay::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_IntervalDay::~Type_IntervalDay() {
+  // @@protoc_insertion_point(destructor:substrait.Type.IntervalDay)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_IntervalDay::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_IntervalDay::ArenaDtor(void* object) {
+  Type_IntervalDay* _this = reinterpret_cast< Type_IntervalDay* >(object);
+  (void)_this;
+}
+void Type_IntervalDay::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_IntervalDay::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_IntervalDay::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.IntervalDay)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_IntervalDay::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_IntervalDay::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.IntervalDay)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.IntervalDay)
+  return target;
+}
+
+size_t Type_IntervalDay::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.IntervalDay)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_IntervalDay::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_IntervalDay::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_IntervalDay::GetClassData() const { return &_class_data_; }
+
+void Type_IntervalDay::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_IntervalDay *>(to)->MergeFrom(
+      static_cast<const Type_IntervalDay &>(from));
+}
+
+
+void Type_IntervalDay::MergeFrom(const Type_IntervalDay& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.IntervalDay)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_IntervalDay::CopyFrom(const Type_IntervalDay& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.IntervalDay)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_IntervalDay::IsInitialized() const {
+  return true;
+}
+
+void Type_IntervalDay::InternalSwap(Type_IntervalDay* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_IntervalDay, nullability_)
+      + sizeof(Type_IntervalDay::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_IntervalDay, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_IntervalDay::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[14]);
+}
+
+// ===================================================================
+
+class Type_UUID::_Internal {
+ public:
+};
+
+Type_UUID::Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.UUID)
+}
+Type_UUID::Type_UUID(const Type_UUID& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.UUID)
+}
+
+inline void Type_UUID::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_UUID::~Type_UUID() {
+  // @@protoc_insertion_point(destructor:substrait.Type.UUID)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_UUID::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_UUID::ArenaDtor(void* object) {
+  Type_UUID* _this = reinterpret_cast< Type_UUID* >(object);
+  (void)_this;
+}
+void Type_UUID::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_UUID::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_UUID::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.UUID)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_UUID::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // uint32 type_variation_reference = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_UUID::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.UUID)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      2, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.UUID)
+  return target;
+}
+
+size_t Type_UUID::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.UUID)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // uint32 type_variation_reference = 1;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 2;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_UUID::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_UUID::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_UUID::GetClassData() const { return &_class_data_; }
+
+void Type_UUID::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_UUID *>(to)->MergeFrom(
+      static_cast<const Type_UUID &>(from));
+}
+
+
+void Type_UUID::MergeFrom(const Type_UUID& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.UUID)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_UUID::CopyFrom(const Type_UUID& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.UUID)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_UUID::IsInitialized() const {
+  return true;
+}
+
+void Type_UUID::InternalSwap(Type_UUID* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_UUID, nullability_)
+      + sizeof(Type_UUID::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_UUID, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_UUID::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[15]);
+}
+
+// ===================================================================
+
+class Type_FixedChar::_Internal {
+ public:
+};
+
+Type_FixedChar::Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.FixedChar)
+}
+Type_FixedChar::Type_FixedChar(const Type_FixedChar& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&length_, &from.length_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.FixedChar)
+}
+
+inline void Type_FixedChar::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&length_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+}
+
+Type_FixedChar::~Type_FixedChar() {
+  // @@protoc_insertion_point(destructor:substrait.Type.FixedChar)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_FixedChar::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_FixedChar::ArenaDtor(void* object) {
+  Type_FixedChar* _this = reinterpret_cast< Type_FixedChar* >(object);
+  (void)_this;
+}
+void Type_FixedChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_FixedChar::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_FixedChar::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.FixedChar)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&length_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_FixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 length = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 type_variation_reference = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_FixedChar::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FixedChar)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 length = 1;
+  if (this->_internal_length() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target);
+  }
+
+  // uint32 type_variation_reference = 2;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.FixedChar)
+  return target;
+}
+
+size_t Type_FixedChar::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.FixedChar)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 length = 1;
+  if (this->_internal_length() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_length());
+  }
+
+  // uint32 type_variation_reference = 2;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_FixedChar::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_FixedChar::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_FixedChar::GetClassData() const { return &_class_data_; }
+
+void Type_FixedChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_FixedChar *>(to)->MergeFrom(
+      static_cast<const Type_FixedChar &>(from));
+}
+
+
+void Type_FixedChar::MergeFrom(const Type_FixedChar& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FixedChar)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_length() != 0) {
+    _internal_set_length(from._internal_length());
+  }
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_FixedChar::CopyFrom(const Type_FixedChar& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.FixedChar)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_FixedChar::IsInitialized() const {
+  return true;
+}
+
+void Type_FixedChar::InternalSwap(Type_FixedChar* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_FixedChar, nullability_)
+      + sizeof(Type_FixedChar::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_FixedChar, length_)>(
+          reinterpret_cast<char*>(&length_),
+          reinterpret_cast<char*>(&other->length_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_FixedChar::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[16]);
+}
+
+// ===================================================================
+
+class Type_VarChar::_Internal {
+ public:
+};
+
+Type_VarChar::Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.VarChar)
+}
+Type_VarChar::Type_VarChar(const Type_VarChar& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&length_, &from.length_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.VarChar)
+}
+
+inline void Type_VarChar::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&length_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+}
+
+Type_VarChar::~Type_VarChar() {
+  // @@protoc_insertion_point(destructor:substrait.Type.VarChar)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_VarChar::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_VarChar::ArenaDtor(void* object) {
+  Type_VarChar* _this = reinterpret_cast< Type_VarChar* >(object);
+  (void)_this;
+}
+void Type_VarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_VarChar::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_VarChar::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.VarChar)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&length_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_VarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 length = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 type_variation_reference = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_VarChar::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.VarChar)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 length = 1;
+  if (this->_internal_length() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target);
+  }
+
+  // uint32 type_variation_reference = 2;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.VarChar)
+  return target;
+}
+
+size_t Type_VarChar::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.VarChar)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 length = 1;
+  if (this->_internal_length() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_length());
+  }
+
+  // uint32 type_variation_reference = 2;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_VarChar::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_VarChar::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_VarChar::GetClassData() const { return &_class_data_; }
+
+void Type_VarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_VarChar *>(to)->MergeFrom(
+      static_cast<const Type_VarChar &>(from));
+}
+
+
+void Type_VarChar::MergeFrom(const Type_VarChar& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.VarChar)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_length() != 0) {
+    _internal_set_length(from._internal_length());
+  }
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_VarChar::CopyFrom(const Type_VarChar& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.VarChar)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_VarChar::IsInitialized() const {
+  return true;
+}
+
+void Type_VarChar::InternalSwap(Type_VarChar* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_VarChar, nullability_)
+      + sizeof(Type_VarChar::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_VarChar, length_)>(
+          reinterpret_cast<char*>(&length_),
+          reinterpret_cast<char*>(&other->length_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_VarChar::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[17]);
+}
+
+// ===================================================================
+
+class Type_FixedBinary::_Internal {
+ public:
+};
+
+Type_FixedBinary::Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.FixedBinary)
+}
+Type_FixedBinary::Type_FixedBinary(const Type_FixedBinary& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&length_, &from.length_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.FixedBinary)
+}
+
+inline void Type_FixedBinary::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&length_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+}
+
+Type_FixedBinary::~Type_FixedBinary() {
+  // @@protoc_insertion_point(destructor:substrait.Type.FixedBinary)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_FixedBinary::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_FixedBinary::ArenaDtor(void* object) {
+  Type_FixedBinary* _this = reinterpret_cast< Type_FixedBinary* >(object);
+  (void)_this;
+}
+void Type_FixedBinary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_FixedBinary::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_FixedBinary::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.FixedBinary)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&length_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_FixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 length = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 type_variation_reference = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_FixedBinary::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FixedBinary)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 length = 1;
+  if (this->_internal_length() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target);
+  }
+
+  // uint32 type_variation_reference = 2;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.FixedBinary)
+  return target;
+}
+
+size_t Type_FixedBinary::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.FixedBinary)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 length = 1;
+  if (this->_internal_length() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_length());
+  }
+
+  // uint32 type_variation_reference = 2;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_FixedBinary::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_FixedBinary::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_FixedBinary::GetClassData() const { return &_class_data_; }
+
+void Type_FixedBinary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_FixedBinary *>(to)->MergeFrom(
+      static_cast<const Type_FixedBinary &>(from));
+}
+
+
+void Type_FixedBinary::MergeFrom(const Type_FixedBinary& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FixedBinary)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_length() != 0) {
+    _internal_set_length(from._internal_length());
+  }
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_FixedBinary::CopyFrom(const Type_FixedBinary& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.FixedBinary)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_FixedBinary::IsInitialized() const {
+  return true;
+}
+
+void Type_FixedBinary::InternalSwap(Type_FixedBinary* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_FixedBinary, nullability_)
+      + sizeof(Type_FixedBinary::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_FixedBinary, length_)>(
+          reinterpret_cast<char*>(&length_),
+          reinterpret_cast<char*>(&other->length_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_FixedBinary::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[18]);
+}
+
+// ===================================================================
+
+class Type_Decimal::_Internal {
+ public:
+};
+
+Type_Decimal::Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.Decimal)
+}
+Type_Decimal::Type_Decimal(const Type_Decimal& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&scale_, &from.scale_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&scale_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.Decimal)
+}
+
+inline void Type_Decimal::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&scale_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&scale_)) + sizeof(nullability_));
+}
+
+Type_Decimal::~Type_Decimal() {
+  // @@protoc_insertion_point(destructor:substrait.Type.Decimal)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_Decimal::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_Decimal::ArenaDtor(void* object) {
+  Type_Decimal* _this = reinterpret_cast< Type_Decimal* >(object);
+  (void)_this;
+}
+void Type_Decimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_Decimal::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_Decimal::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.Decimal)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&scale_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&scale_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_Decimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // int32 scale = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          scale_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 precision = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          precision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 type_variation_reference = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_Decimal::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Decimal)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 scale = 1;
+  if (this->_internal_scale() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_scale(), target);
+  }
+
+  // int32 precision = 2;
+  if (this->_internal_precision() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_precision(), target);
+  }
+
+  // uint32 type_variation_reference = 3;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 4;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Decimal)
+  return target;
+}
+
+size_t Type_Decimal::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Decimal)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 scale = 1;
+  if (this->_internal_scale() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_scale());
+  }
+
+  // int32 precision = 2;
+  if (this->_internal_precision() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_precision());
+  }
+
+  // uint32 type_variation_reference = 3;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 4;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Decimal::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_Decimal::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Decimal::GetClassData() const { return &_class_data_; }
+
+void Type_Decimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_Decimal *>(to)->MergeFrom(
+      static_cast<const Type_Decimal &>(from));
+}
+
+
+void Type_Decimal::MergeFrom(const Type_Decimal& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Decimal)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_scale() != 0) {
+    _internal_set_scale(from._internal_scale());
+  }
+  if (from._internal_precision() != 0) {
+    _internal_set_precision(from._internal_precision());
+  }
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_Decimal::CopyFrom(const Type_Decimal& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Decimal)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_Decimal::IsInitialized() const {
+  return true;
+}
+
+void Type_Decimal::InternalSwap(Type_Decimal* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_Decimal, nullability_)
+      + sizeof(Type_Decimal::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_Decimal, scale_)>(
+          reinterpret_cast<char*>(&scale_),
+          reinterpret_cast<char*>(&other->scale_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_Decimal::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[19]);
+}
+
+// ===================================================================
+
+class Type_Struct::_Internal {
+ public:
+};
+
+Type_Struct::Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  types_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.Struct)
+}
+Type_Struct::Type_Struct(const Type_Struct& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      types_(from.types_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.Struct)
+}
+
+inline void Type_Struct::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_variation_reference_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+}
+
+Type_Struct::~Type_Struct() {
+  // @@protoc_insertion_point(destructor:substrait.Type.Struct)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_Struct::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void Type_Struct::ArenaDtor(void* object) {
+  Type_Struct* _this = reinterpret_cast< Type_Struct* >(object);
+  (void)_this;
+}
+void Type_Struct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_Struct::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_Struct::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.Struct)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  types_.Clear();
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.Type types = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_types(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 type_variation_reference = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_Struct::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Struct)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.Type types = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_types_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_types(i), target, stream);
+  }
+
+  // uint32 type_variation_reference = 2;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Struct)
+  return target;
+}
+
+size_t Type_Struct::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Struct)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.Type types = 1;
+  total_size += 1UL * this->_internal_types_size();
+  for (const auto& msg : this->types_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // uint32 type_variation_reference = 2;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Struct::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_Struct::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Struct::GetClassData() const { return &_class_data_; }
+
+void Type_Struct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_Struct *>(to)->MergeFrom(
+      static_cast<const Type_Struct &>(from));
+}
+
+
+void Type_Struct::MergeFrom(const Type_Struct& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Struct)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  types_.MergeFrom(from.types_);
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_Struct::CopyFrom(const Type_Struct& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Struct)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_Struct::IsInitialized() const {
+  return true;
+}
+
+void Type_Struct::InternalSwap(Type_Struct* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  types_.InternalSwap(&other->types_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_Struct, nullability_)
+      + sizeof(Type_Struct::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_Struct, type_variation_reference_)>(
+          reinterpret_cast<char*>(&type_variation_reference_),
+          reinterpret_cast<char*>(&other->type_variation_reference_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_Struct::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[20]);
+}
+
+// ===================================================================
+
+class Type_List::_Internal {
+ public:
+  static const ::substrait::Type& type(const Type_List* msg);
+};
+
+const ::substrait::Type&
+Type_List::_Internal::type(const Type_List* msg) {
+  return *msg->type_;
+}
+Type_List::Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.List)
+}
+Type_List::Type_List(const Type_List& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_type()) {
+    type_ = new ::substrait::Type(*from.type_);
+  } else {
+    type_ = nullptr;
+  }
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.List)
+}
+
+inline void Type_List::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_)) + sizeof(nullability_));
+}
+
+Type_List::~Type_List() {
+  // @@protoc_insertion_point(destructor:substrait.Type.List)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_List::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete type_;
+}
+
+void Type_List::ArenaDtor(void* object) {
+  Type_List* _this = reinterpret_cast< Type_List* >(object);
+  (void)_this;
+}
+void Type_List::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_List::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_List::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.List)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
+    delete type_;
+  }
+  type_ = nullptr;
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Type type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 type_variation_reference = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_List::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.List)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Type type = 1;
+  if (this->_internal_has_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::type(this), target, stream);
+  }
+
+  // uint32 type_variation_reference = 2;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.List)
+  return target;
+}
+
+size_t Type_List::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.List)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Type type = 1;
+  if (this->_internal_has_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *type_);
+  }
+
+  // uint32 type_variation_reference = 2;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_List::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_List::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_List::GetClassData() const { return &_class_data_; }
+
+void Type_List::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_List *>(to)->MergeFrom(
+      static_cast<const Type_List &>(from));
+}
+
+
+void Type_List::MergeFrom(const Type_List& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.List)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_type()) {
+    _internal_mutable_type()->::substrait::Type::MergeFrom(from._internal_type());
+  }
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_List::CopyFrom(const Type_List& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.List)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_List::IsInitialized() const {
+  return true;
+}
+
+void Type_List::InternalSwap(Type_List* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_List, nullability_)
+      + sizeof(Type_List::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_List, type_)>(
+          reinterpret_cast<char*>(&type_),
+          reinterpret_cast<char*>(&other->type_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_List::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[21]);
+}
+
+// ===================================================================
+
+class Type_Map::_Internal {
+ public:
+  static const ::substrait::Type& key(const Type_Map* msg);
+  static const ::substrait::Type& value(const Type_Map* msg);
+};
+
+const ::substrait::Type&
+Type_Map::_Internal::key(const Type_Map* msg) {
+  return *msg->key_;
+}
+const ::substrait::Type&
+Type_Map::_Internal::value(const Type_Map* msg) {
+  return *msg->value_;
+}
+Type_Map::Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type.Map)
+}
+Type_Map::Type_Map(const Type_Map& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_key()) {
+    key_ = new ::substrait::Type(*from.key_);
+  } else {
+    key_ = nullptr;
+  }
+  if (from._internal_has_value()) {
+    value_ = new ::substrait::Type(*from.value_);
+  } else {
+    value_ = nullptr;
+  }
+  ::memcpy(&type_variation_reference_, &from.type_variation_reference_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.Type.Map)
+}
+
+inline void Type_Map::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&key_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&key_)) + sizeof(nullability_));
+}
+
+Type_Map::~Type_Map() {
+  // @@protoc_insertion_point(destructor:substrait.Type.Map)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type_Map::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete key_;
+  if (this != internal_default_instance()) delete value_;
+}
+
+void Type_Map::ArenaDtor(void* object) {
+  Type_Map* _this = reinterpret_cast< Type_Map* >(object);
+  (void)_this;
+}
+void Type_Map::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type_Map::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type_Map::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type.Map)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && key_ != nullptr) {
+    delete key_;
+  }
+  key_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && value_ != nullptr) {
+    delete value_;
+  }
+  value_ = nullptr;
+  ::memset(&type_variation_reference_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&type_variation_reference_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Type key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 type_variation_reference = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type_Map::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Map)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Type key = 1;
+  if (this->_internal_has_key()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::key(this), target, stream);
+  }
+
+  // .substrait.Type value = 2;
+  if (this->_internal_has_value()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::value(this), target, stream);
+  }
+
+  // uint32 type_variation_reference = 3;
+  if (this->_internal_type_variation_reference() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_type_variation_reference(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 4;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Map)
+  return target;
+}
+
+size_t Type_Map::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Map)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.Type key = 1;
+  if (this->_internal_has_key()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *key_);
+  }
+
+  // .substrait.Type value = 2;
+  if (this->_internal_has_value()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *value_);
+  }
+
+  // uint32 type_variation_reference = 3;
+  if (this->_internal_type_variation_reference() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference());
+  }
+
+  // .substrait.Type.Nullability nullability = 4;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Map::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type_Map::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Map::GetClassData() const { return &_class_data_; }
+
+void Type_Map::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type_Map *>(to)->MergeFrom(
+      static_cast<const Type_Map &>(from));
+}
+
+
+void Type_Map::MergeFrom(const Type_Map& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Map)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_key()) {
+    _internal_mutable_key()->::substrait::Type::MergeFrom(from._internal_key());
+  }
+  if (from._internal_has_value()) {
+    _internal_mutable_value()->::substrait::Type::MergeFrom(from._internal_value());
+  }
+  if (from._internal_type_variation_reference() != 0) {
+    _internal_set_type_variation_reference(from._internal_type_variation_reference());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type_Map::CopyFrom(const Type_Map& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Map)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type_Map::IsInitialized() const {
+  return true;
+}
+
+void Type_Map::InternalSwap(Type_Map* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(Type_Map, nullability_)
+      + sizeof(Type_Map::nullability_)
+      - PROTOBUF_FIELD_OFFSET(Type_Map, key_)>(
+          reinterpret_cast<char*>(&key_),
+          reinterpret_cast<char*>(&other->key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type_Map::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[22]);
+}
+
+// ===================================================================
+
+class Type::_Internal {
+ public:
+  static const ::substrait::Type_Boolean& bool_(const Type* msg);
+  static const ::substrait::Type_I8& i8(const Type* msg);
+  static const ::substrait::Type_I16& i16(const Type* msg);
+  static const ::substrait::Type_I32& i32(const Type* msg);
+  static const ::substrait::Type_I64& i64(const Type* msg);
+  static const ::substrait::Type_FP32& fp32(const Type* msg);
+  static const ::substrait::Type_FP64& fp64(const Type* msg);
+  static const ::substrait::Type_String& string(const Type* msg);
+  static const ::substrait::Type_Binary& binary(const Type* msg);
+  static const ::substrait::Type_Timestamp& timestamp(const Type* msg);
+  static const ::substrait::Type_Date& date(const Type* msg);
+  static const ::substrait::Type_Time& time(const Type* msg);
+  static const ::substrait::Type_IntervalYear& interval_year(const Type* msg);
+  static const ::substrait::Type_IntervalDay& interval_day(const Type* msg);
+  static const ::substrait::Type_TimestampTZ& timestamp_tz(const Type* msg);
+  static const ::substrait::Type_UUID& uuid(const Type* msg);
+  static const ::substrait::Type_FixedChar& fixed_char(const Type* msg);
+  static const ::substrait::Type_VarChar& varchar(const Type* msg);
+  static const ::substrait::Type_FixedBinary& fixed_binary(const Type* msg);
+  static const ::substrait::Type_Decimal& decimal(const Type* msg);
+  static const ::substrait::Type_Struct& struct_(const Type* msg);
+  static const ::substrait::Type_List& list(const Type* msg);
+  static const ::substrait::Type_Map& map(const Type* msg);
+};
+
+const ::substrait::Type_Boolean&
+Type::_Internal::bool_(const Type* msg) {
+  return *msg->kind_.bool__;
+}
+const ::substrait::Type_I8&
+Type::_Internal::i8(const Type* msg) {
+  return *msg->kind_.i8_;
+}
+const ::substrait::Type_I16&
+Type::_Internal::i16(const Type* msg) {
+  return *msg->kind_.i16_;
+}
+const ::substrait::Type_I32&
+Type::_Internal::i32(const Type* msg) {
+  return *msg->kind_.i32_;
+}
+const ::substrait::Type_I64&
+Type::_Internal::i64(const Type* msg) {
+  return *msg->kind_.i64_;
+}
+const ::substrait::Type_FP32&
+Type::_Internal::fp32(const Type* msg) {
+  return *msg->kind_.fp32_;
+}
+const ::substrait::Type_FP64&
+Type::_Internal::fp64(const Type* msg) {
+  return *msg->kind_.fp64_;
+}
+const ::substrait::Type_String&
+Type::_Internal::string(const Type* msg) {
+  return *msg->kind_.string_;
+}
+const ::substrait::Type_Binary&
+Type::_Internal::binary(const Type* msg) {
+  return *msg->kind_.binary_;
+}
+const ::substrait::Type_Timestamp&
+Type::_Internal::timestamp(const Type* msg) {
+  return *msg->kind_.timestamp_;
+}
+const ::substrait::Type_Date&
+Type::_Internal::date(const Type* msg) {
+  return *msg->kind_.date_;
+}
+const ::substrait::Type_Time&
+Type::_Internal::time(const Type* msg) {
+  return *msg->kind_.time_;
+}
+const ::substrait::Type_IntervalYear&
+Type::_Internal::interval_year(const Type* msg) {
+  return *msg->kind_.interval_year_;
+}
+const ::substrait::Type_IntervalDay&
+Type::_Internal::interval_day(const Type* msg) {
+  return *msg->kind_.interval_day_;
+}
+const ::substrait::Type_TimestampTZ&
+Type::_Internal::timestamp_tz(const Type* msg) {
+  return *msg->kind_.timestamp_tz_;
+}
+const ::substrait::Type_UUID&
+Type::_Internal::uuid(const Type* msg) {
+  return *msg->kind_.uuid_;
+}
+const ::substrait::Type_FixedChar&
+Type::_Internal::fixed_char(const Type* msg) {
+  return *msg->kind_.fixed_char_;
+}
+const ::substrait::Type_VarChar&
+Type::_Internal::varchar(const Type* msg) {
+  return *msg->kind_.varchar_;
+}
+const ::substrait::Type_FixedBinary&
+Type::_Internal::fixed_binary(const Type* msg) {
+  return *msg->kind_.fixed_binary_;
+}
+const ::substrait::Type_Decimal&
+Type::_Internal::decimal(const Type* msg) {
+  return *msg->kind_.decimal_;
+}
+const ::substrait::Type_Struct&
+Type::_Internal::struct_(const Type* msg) {
+  return *msg->kind_.struct__;
+}
+const ::substrait::Type_List&
+Type::_Internal::list(const Type* msg) {
+  return *msg->kind_.list_;
+}
+const ::substrait::Type_Map&
+Type::_Internal::map(const Type* msg) {
+  return *msg->kind_.map_;
+}
+void Type::set_allocated_bool_(::substrait::Type_Boolean* bool_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (bool_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Boolean>::GetOwningArena(bool_);
+    if (message_arena != submessage_arena) {
+      bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, bool_, submessage_arena);
+    }
+    set_has_bool_();
+    kind_.bool__ = bool_;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.bool)
+}
+void Type::set_allocated_i8(::substrait::Type_I8* i8) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (i8) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_I8>::GetOwningArena(i8);
+    if (message_arena != submessage_arena) {
+      i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, i8, submessage_arena);
+    }
+    set_has_i8();
+    kind_.i8_ = i8;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.i8)
+}
+void Type::set_allocated_i16(::substrait::Type_I16* i16) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (i16) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_I16>::GetOwningArena(i16);
+    if (message_arena != submessage_arena) {
+      i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, i16, submessage_arena);
+    }
+    set_has_i16();
+    kind_.i16_ = i16;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.i16)
+}
+void Type::set_allocated_i32(::substrait::Type_I32* i32) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (i32) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_I32>::GetOwningArena(i32);
+    if (message_arena != submessage_arena) {
+      i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, i32, submessage_arena);
+    }
+    set_has_i32();
+    kind_.i32_ = i32;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.i32)
+}
+void Type::set_allocated_i64(::substrait::Type_I64* i64) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (i64) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_I64>::GetOwningArena(i64);
+    if (message_arena != submessage_arena) {
+      i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, i64, submessage_arena);
+    }
+    set_has_i64();
+    kind_.i64_ = i64;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.i64)
+}
+void Type::set_allocated_fp32(::substrait::Type_FP32* fp32) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (fp32) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_FP32>::GetOwningArena(fp32);
+    if (message_arena != submessage_arena) {
+      fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fp32, submessage_arena);
+    }
+    set_has_fp32();
+    kind_.fp32_ = fp32;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.fp32)
+}
+void Type::set_allocated_fp64(::substrait::Type_FP64* fp64) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (fp64) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_FP64>::GetOwningArena(fp64);
+    if (message_arena != submessage_arena) {
+      fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fp64, submessage_arena);
+    }
+    set_has_fp64();
+    kind_.fp64_ = fp64;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.fp64)
+}
+void Type::set_allocated_string(::substrait::Type_String* string) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (string) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_String>::GetOwningArena(string);
+    if (message_arena != submessage_arena) {
+      string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, string, submessage_arena);
+    }
+    set_has_string();
+    kind_.string_ = string;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.string)
+}
+void Type::set_allocated_binary(::substrait::Type_Binary* binary) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (binary) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Binary>::GetOwningArena(binary);
+    if (message_arena != submessage_arena) {
+      binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, binary, submessage_arena);
+    }
+    set_has_binary();
+    kind_.binary_ = binary;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.binary)
+}
+void Type::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (timestamp) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Timestamp>::GetOwningArena(timestamp);
+    if (message_arena != submessage_arena) {
+      timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    set_has_timestamp();
+    kind_.timestamp_ = timestamp;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.timestamp)
+}
+void Type::set_allocated_date(::substrait::Type_Date* date) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (date) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Date>::GetOwningArena(date);
+    if (message_arena != submessage_arena) {
+      date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, date, submessage_arena);
+    }
+    set_has_date();
+    kind_.date_ = date;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.date)
+}
+void Type::set_allocated_time(::substrait::Type_Time* time) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (time) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Time>::GetOwningArena(time);
+    if (message_arena != submessage_arena) {
+      time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, time, submessage_arena);
+    }
+    set_has_time();
+    kind_.time_ = time;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.time)
+}
+void Type::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (interval_year) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_IntervalYear>::GetOwningArena(interval_year);
+    if (message_arena != submessage_arena) {
+      interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, interval_year, submessage_arena);
+    }
+    set_has_interval_year();
+    kind_.interval_year_ = interval_year;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.interval_year)
+}
+void Type::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (interval_day) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_IntervalDay>::GetOwningArena(interval_day);
+    if (message_arena != submessage_arena) {
+      interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, interval_day, submessage_arena);
+    }
+    set_has_interval_day();
+    kind_.interval_day_ = interval_day;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.interval_day)
+}
+void Type::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (timestamp_tz) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_TimestampTZ>::GetOwningArena(timestamp_tz);
+    if (message_arena != submessage_arena) {
+      timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, timestamp_tz, submessage_arena);
+    }
+    set_has_timestamp_tz();
+    kind_.timestamp_tz_ = timestamp_tz;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.timestamp_tz)
+}
+void Type::set_allocated_uuid(::substrait::Type_UUID* uuid) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (uuid) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_UUID>::GetOwningArena(uuid);
+    if (message_arena != submessage_arena) {
+      uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, uuid, submessage_arena);
+    }
+    set_has_uuid();
+    kind_.uuid_ = uuid;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.uuid)
+}
+void Type::set_allocated_fixed_char(::substrait::Type_FixedChar* fixed_char) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (fixed_char) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_FixedChar>::GetOwningArena(fixed_char);
+    if (message_arena != submessage_arena) {
+      fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fixed_char, submessage_arena);
+    }
+    set_has_fixed_char();
+    kind_.fixed_char_ = fixed_char;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.fixed_char)
+}
+void Type::set_allocated_varchar(::substrait::Type_VarChar* varchar) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (varchar) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_VarChar>::GetOwningArena(varchar);
+    if (message_arena != submessage_arena) {
+      varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, varchar, submessage_arena);
+    }
+    set_has_varchar();
+    kind_.varchar_ = varchar;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.varchar)
+}
+void Type::set_allocated_fixed_binary(::substrait::Type_FixedBinary* fixed_binary) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (fixed_binary) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_FixedBinary>::GetOwningArena(fixed_binary);
+    if (message_arena != submessage_arena) {
+      fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fixed_binary, submessage_arena);
+    }
+    set_has_fixed_binary();
+    kind_.fixed_binary_ = fixed_binary;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.fixed_binary)
+}
+void Type::set_allocated_decimal(::substrait::Type_Decimal* decimal) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (decimal) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Decimal>::GetOwningArena(decimal);
+    if (message_arena != submessage_arena) {
+      decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, decimal, submessage_arena);
+    }
+    set_has_decimal();
+    kind_.decimal_ = decimal;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.decimal)
+}
+void Type::set_allocated_struct_(::substrait::Type_Struct* struct_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (struct_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Struct>::GetOwningArena(struct_);
+    if (message_arena != submessage_arena) {
+      struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, struct_, submessage_arena);
+    }
+    set_has_struct_();
+    kind_.struct__ = struct_;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.struct)
+}
+void Type::set_allocated_list(::substrait::Type_List* list) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (list) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_List>::GetOwningArena(list);
+    if (message_arena != submessage_arena) {
+      list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, list, submessage_arena);
+    }
+    set_has_list();
+    kind_.list_ = list;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.list)
+}
+void Type::set_allocated_map(::substrait::Type_Map* map) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (map) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Map>::GetOwningArena(map);
+    if (message_arena != submessage_arena) {
+      map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, map, submessage_arena);
+    }
+    set_has_map();
+    kind_.map_ = map;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.map)
+}
+Type::Type(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.Type)
+}
+Type::Type(const Type& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_kind();
+  switch (from.kind_case()) {
+    case kBool: {
+      _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_());
+      break;
+    }
+    case kI8: {
+      _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8());
+      break;
+    }
+    case kI16: {
+      _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16());
+      break;
+    }
+    case kI32: {
+      _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32());
+      break;
+    }
+    case kI64: {
+      _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64());
+      break;
+    }
+    case kFp32: {
+      _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32());
+      break;
+    }
+    case kFp64: {
+      _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64());
+      break;
+    }
+    case kString: {
+      _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string());
+      break;
+    }
+    case kBinary: {
+      _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary());
+      break;
+    }
+    case kTimestamp: {
+      _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp());
+      break;
+    }
+    case kDate: {
+      _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date());
+      break;
+    }
+    case kTime: {
+      _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time());
+      break;
+    }
+    case kIntervalYear: {
+      _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year());
+      break;
+    }
+    case kIntervalDay: {
+      _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day());
+      break;
+    }
+    case kTimestampTz: {
+      _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz());
+      break;
+    }
+    case kUuid: {
+      _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid());
+      break;
+    }
+    case kFixedChar: {
+      _internal_mutable_fixed_char()->::substrait::Type_FixedChar::MergeFrom(from._internal_fixed_char());
+      break;
+    }
+    case kVarchar: {
+      _internal_mutable_varchar()->::substrait::Type_VarChar::MergeFrom(from._internal_varchar());
+      break;
+    }
+    case kFixedBinary: {
+      _internal_mutable_fixed_binary()->::substrait::Type_FixedBinary::MergeFrom(from._internal_fixed_binary());
+      break;
+    }
+    case kDecimal: {
+      _internal_mutable_decimal()->::substrait::Type_Decimal::MergeFrom(from._internal_decimal());
+      break;
+    }
+    case kStruct: {
+      _internal_mutable_struct_()->::substrait::Type_Struct::MergeFrom(from._internal_struct_());
+      break;
+    }
+    case kList: {
+      _internal_mutable_list()->::substrait::Type_List::MergeFrom(from._internal_list());
+      break;
+    }
+    case kMap: {
+      _internal_mutable_map()->::substrait::Type_Map::MergeFrom(from._internal_map());
+      break;
+    }
+    case kUserDefinedTypeReference: {
+      _internal_set_user_defined_type_reference(from._internal_user_defined_type_reference());
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.Type)
+}
+
+inline void Type::SharedCtor() {
+clear_has_kind();
+}
+
+Type::~Type() {
+  // @@protoc_insertion_point(destructor:substrait.Type)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void Type::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_kind()) {
+    clear_kind();
+  }
+}
+
+void Type::ArenaDtor(void* object) {
+  Type* _this = reinterpret_cast< Type* >(object);
+  (void)_this;
+}
+void Type::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void Type::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void Type::clear_kind() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.Type)
+  switch (kind_case()) {
+    case kBool: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.bool__;
+      }
+      break;
+    }
+    case kI8: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.i8_;
+      }
+      break;
+    }
+    case kI16: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.i16_;
+      }
+      break;
+    }
+    case kI32: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.i32_;
+      }
+      break;
+    }
+    case kI64: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.i64_;
+      }
+      break;
+    }
+    case kFp32: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.fp32_;
+      }
+      break;
+    }
+    case kFp64: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.fp64_;
+      }
+      break;
+    }
+    case kString: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.string_;
+      }
+      break;
+    }
+    case kBinary: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.binary_;
+      }
+      break;
+    }
+    case kTimestamp: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.timestamp_;
+      }
+      break;
+    }
+    case kDate: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.date_;
+      }
+      break;
+    }
+    case kTime: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.time_;
+      }
+      break;
+    }
+    case kIntervalYear: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.interval_year_;
+      }
+      break;
+    }
+    case kIntervalDay: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.interval_day_;
+      }
+      break;
+    }
+    case kTimestampTz: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.timestamp_tz_;
+      }
+      break;
+    }
+    case kUuid: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.uuid_;
+      }
+      break;
+    }
+    case kFixedChar: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.fixed_char_;
+      }
+      break;
+    }
+    case kVarchar: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.varchar_;
+      }
+      break;
+    }
+    case kFixedBinary: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.fixed_binary_;
+      }
+      break;
+    }
+    case kDecimal: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.decimal_;
+      }
+      break;
+    }
+    case kStruct: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.struct__;
+      }
+      break;
+    }
+    case kList: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.list_;
+      }
+      break;
+    }
+    case kMap: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.map_;
+      }
+      break;
+    }
+    case kUserDefinedTypeReference: {
+      // No need to clear
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = KIND_NOT_SET;
+}
+
+
+void Type::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.Type)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_kind();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* Type::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Type.Boolean bool = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.I8 i8 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.I16 i16 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.I32 i32 = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.I64 i64 = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.FP32 fp32 = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.FP64 fp64 = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.String string = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          ptr = ctx->ParseMessage(_internal_mutable_string(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Binary binary = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Timestamp timestamp = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
+          ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Date date = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          ptr = ctx->ParseMessage(_internal_mutable_date(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Time time = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_time(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.IntervalYear interval_year = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.IntervalDay interval_day = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
+          ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.FixedChar fixed_char = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.VarChar varchar = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
+          ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.FixedBinary fixed_binary = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Decimal decimal = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 194)) {
+          ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Struct struct = 25;
+      case 25:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 202)) {
+          ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.List list = 27;
+      case 27:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 218)) {
+          ptr = ctx->ParseMessage(_internal_mutable_list(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Map map = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 226)) {
+          ptr = ctx->ParseMessage(_internal_mutable_map(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.TimestampTZ timestamp_tz = 29;
+      case 29:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 234)) {
+          ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 user_defined_type_reference = 31;
+      case 31:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
+          _internal_set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.UUID uuid = 32;
+      case 32:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 2)) {
+          ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* Type::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.Type)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Type.Boolean bool = 1;
+  if (_internal_has_bool_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::bool_(this), target, stream);
+  }
+
+  // .substrait.Type.I8 i8 = 2;
+  if (_internal_has_i8()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::i8(this), target, stream);
+  }
+
+  // .substrait.Type.I16 i16 = 3;
+  if (_internal_has_i16()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::i16(this), target, stream);
+  }
+
+  // .substrait.Type.I32 i32 = 5;
+  if (_internal_has_i32()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        5, _Internal::i32(this), target, stream);
+  }
+
+  // .substrait.Type.I64 i64 = 7;
+  if (_internal_has_i64()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        7, _Internal::i64(this), target, stream);
+  }
+
+  // .substrait.Type.FP32 fp32 = 10;
+  if (_internal_has_fp32()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::fp32(this), target, stream);
+  }
+
+  // .substrait.Type.FP64 fp64 = 11;
+  if (_internal_has_fp64()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        11, _Internal::fp64(this), target, stream);
+  }
+
+  // .substrait.Type.String string = 12;
+  if (_internal_has_string()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        12, _Internal::string(this), target, stream);
+  }
+
+  // .substrait.Type.Binary binary = 13;
+  if (_internal_has_binary()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        13, _Internal::binary(this), target, stream);
+  }
+
+  // .substrait.Type.Timestamp timestamp = 14;
+  if (_internal_has_timestamp()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        14, _Internal::timestamp(this), target, stream);
+  }
+
+  // .substrait.Type.Date date = 16;
+  if (_internal_has_date()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        16, _Internal::date(this), target, stream);
+  }
+
+  // .substrait.Type.Time time = 17;
+  if (_internal_has_time()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        17, _Internal::time(this), target, stream);
+  }
+
+  // .substrait.Type.IntervalYear interval_year = 19;
+  if (_internal_has_interval_year()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        19, _Internal::interval_year(this), target, stream);
+  }
+
+  // .substrait.Type.IntervalDay interval_day = 20;
+  if (_internal_has_interval_day()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        20, _Internal::interval_day(this), target, stream);
+  }
+
+  // .substrait.Type.FixedChar fixed_char = 21;
+  if (_internal_has_fixed_char()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        21, _Internal::fixed_char(this), target, stream);
+  }
+
+  // .substrait.Type.VarChar varchar = 22;
+  if (_internal_has_varchar()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        22, _Internal::varchar(this), target, stream);
+  }
+
+  // .substrait.Type.FixedBinary fixed_binary = 23;
+  if (_internal_has_fixed_binary()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        23, _Internal::fixed_binary(this), target, stream);
+  }
+
+  // .substrait.Type.Decimal decimal = 24;
+  if (_internal_has_decimal()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        24, _Internal::decimal(this), target, stream);
+  }
+
+  // .substrait.Type.Struct struct = 25;
+  if (_internal_has_struct_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        25, _Internal::struct_(this), target, stream);
+  }
+
+  // .substrait.Type.List list = 27;
+  if (_internal_has_list()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        27, _Internal::list(this), target, stream);
+  }
+
+  // .substrait.Type.Map map = 28;
+  if (_internal_has_map()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        28, _Internal::map(this), target, stream);
+  }
+
+  // .substrait.Type.TimestampTZ timestamp_tz = 29;
+  if (_internal_has_timestamp_tz()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        29, _Internal::timestamp_tz(this), target, stream);
+  }
+
+  // uint32 user_defined_type_reference = 31;
+  if (_internal_has_user_defined_type_reference()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_type_reference(), target);
+  }
+
+  // .substrait.Type.UUID uuid = 32;
+  if (_internal_has_uuid()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        32, _Internal::uuid(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.Type)
+  return target;
+}
+
+size_t Type::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.Type)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (kind_case()) {
+    // .substrait.Type.Boolean bool = 1;
+    case kBool: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.bool__);
+      break;
+    }
+    // .substrait.Type.I8 i8 = 2;
+    case kI8: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.i8_);
+      break;
+    }
+    // .substrait.Type.I16 i16 = 3;
+    case kI16: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.i16_);
+      break;
+    }
+    // .substrait.Type.I32 i32 = 5;
+    case kI32: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.i32_);
+      break;
+    }
+    // .substrait.Type.I64 i64 = 7;
+    case kI64: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.i64_);
+      break;
+    }
+    // .substrait.Type.FP32 fp32 = 10;
+    case kFp32: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.fp32_);
+      break;
+    }
+    // .substrait.Type.FP64 fp64 = 11;
+    case kFp64: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.fp64_);
+      break;
+    }
+    // .substrait.Type.String string = 12;
+    case kString: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.string_);
+      break;
+    }
+    // .substrait.Type.Binary binary = 13;
+    case kBinary: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.binary_);
+      break;
+    }
+    // .substrait.Type.Timestamp timestamp = 14;
+    case kTimestamp: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.timestamp_);
+      break;
+    }
+    // .substrait.Type.Date date = 16;
+    case kDate: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.date_);
+      break;
+    }
+    // .substrait.Type.Time time = 17;
+    case kTime: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.time_);
+      break;
+    }
+    // .substrait.Type.IntervalYear interval_year = 19;
+    case kIntervalYear: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.interval_year_);
+      break;
+    }
+    // .substrait.Type.IntervalDay interval_day = 20;
+    case kIntervalDay: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.interval_day_);
+      break;
+    }
+    // .substrait.Type.TimestampTZ timestamp_tz = 29;
+    case kTimestampTz: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.timestamp_tz_);
+      break;
+    }
+    // .substrait.Type.UUID uuid = 32;
+    case kUuid: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.uuid_);
+      break;
+    }
+    // .substrait.Type.FixedChar fixed_char = 21;
+    case kFixedChar: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.fixed_char_);
+      break;
+    }
+    // .substrait.Type.VarChar varchar = 22;
+    case kVarchar: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.varchar_);
+      break;
+    }
+    // .substrait.Type.FixedBinary fixed_binary = 23;
+    case kFixedBinary: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.fixed_binary_);
+      break;
+    }
+    // .substrait.Type.Decimal decimal = 24;
+    case kDecimal: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.decimal_);
+      break;
+    }
+    // .substrait.Type.Struct struct = 25;
+    case kStruct: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.struct__);
+      break;
+    }
+    // .substrait.Type.List list = 27;
+    case kList: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.list_);
+      break;
+    }
+    // .substrait.Type.Map map = 28;
+    case kMap: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.map_);
+      break;
+    }
+    // uint32 user_defined_type_reference = 31;
+    case kUserDefinedTypeReference: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
+          this->_internal_user_defined_type_reference());
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    Type::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type::GetClassData() const { return &_class_data_; }
+
+void Type::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<Type *>(to)->MergeFrom(
+      static_cast<const Type &>(from));
+}
+
+
+void Type::MergeFrom(const Type& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.kind_case()) {
+    case kBool: {
+      _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_());
+      break;
+    }
+    case kI8: {
+      _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8());
+      break;
+    }
+    case kI16: {
+      _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16());
+      break;
+    }
+    case kI32: {
+      _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32());
+      break;
+    }
+    case kI64: {
+      _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64());
+      break;
+    }
+    case kFp32: {
+      _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32());
+      break;
+    }
+    case kFp64: {
+      _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64());
+      break;
+    }
+    case kString: {
+      _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string());
+      break;
+    }
+    case kBinary: {
+      _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary());
+      break;
+    }
+    case kTimestamp: {
+      _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp());
+      break;
+    }
+    case kDate: {
+      _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date());
+      break;
+    }
+    case kTime: {
+      _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time());
+      break;
+    }
+    case kIntervalYear: {
+      _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year());
+      break;
+    }
+    case kIntervalDay: {
+      _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day());
+      break;
+    }
+    case kTimestampTz: {
+      _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz());
+      break;
+    }
+    case kUuid: {
+      _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid());
+      break;
+    }
+    case kFixedChar: {
+      _internal_mutable_fixed_char()->::substrait::Type_FixedChar::MergeFrom(from._internal_fixed_char());
+      break;
+    }
+    case kVarchar: {
+      _internal_mutable_varchar()->::substrait::Type_VarChar::MergeFrom(from._internal_varchar());
+      break;
+    }
+    case kFixedBinary: {
+      _internal_mutable_fixed_binary()->::substrait::Type_FixedBinary::MergeFrom(from._internal_fixed_binary());
+      break;
+    }
+    case kDecimal: {
+      _internal_mutable_decimal()->::substrait::Type_Decimal::MergeFrom(from._internal_decimal());
+      break;
+    }
+    case kStruct: {
+      _internal_mutable_struct_()->::substrait::Type_Struct::MergeFrom(from._internal_struct_());
+      break;
+    }
+    case kList: {
+      _internal_mutable_list()->::substrait::Type_List::MergeFrom(from._internal_list());
+      break;
+    }
+    case kMap: {
+      _internal_mutable_map()->::substrait::Type_Map::MergeFrom(from._internal_map());
+      break;
+    }
+    case kUserDefinedTypeReference: {
+      _internal_set_user_defined_type_reference(from._internal_user_defined_type_reference());
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void Type::CopyFrom(const Type& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Type::IsInitialized() const {
+  return true;
+}
+
+void Type::InternalSwap(Type* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(kind_, other->kind_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Type::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[23]);
+}
+
+// ===================================================================
+
+class NamedStruct::_Internal {
+ public:
+  static const ::substrait::Type_Struct& struct_(const NamedStruct* msg);
+};
+
+const ::substrait::Type_Struct&
+NamedStruct::_Internal::struct_(const NamedStruct* msg) {
+  return *msg->struct__;
+}
+NamedStruct::NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  names_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.NamedStruct)
+}
+NamedStruct::NamedStruct(const NamedStruct& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      names_(from.names_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_struct_()) {
+    struct__ = new ::substrait::Type_Struct(*from.struct__);
+  } else {
+    struct__ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.NamedStruct)
+}
+
+inline void NamedStruct::SharedCtor() {
+struct__ = nullptr;
+}
+
+NamedStruct::~NamedStruct() {
+  // @@protoc_insertion_point(destructor:substrait.NamedStruct)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void NamedStruct::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete struct__;
+}
+
+void NamedStruct::ArenaDtor(void* object) {
+  NamedStruct* _this = reinterpret_cast< NamedStruct* >(object);
+  (void)_this;
+}
+void NamedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void NamedStruct::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void NamedStruct::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.NamedStruct)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  names_.Clear();
+  if (GetArenaForAllocation() == nullptr && struct__ != nullptr) {
+    delete struct__;
+  }
+  struct__ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* NamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated string names = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_names();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.NamedStruct.names"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Struct struct = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* NamedStruct::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.NamedStruct)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string names = 1;
+  for (int i = 0, n = this->_internal_names_size(); i < n; i++) {
+    const auto& s = this->_internal_names(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.NamedStruct.names");
+    target = stream->WriteString(1, s, target);
+  }
+
+  // .substrait.Type.Struct struct = 2;
+  if (this->_internal_has_struct_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::struct_(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.NamedStruct)
+  return target;
+}
+
+size_t NamedStruct::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.NamedStruct)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string names = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size());
+  for (int i = 0, n = names_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      names_.Get(i));
+  }
+
+  // .substrait.Type.Struct struct = 2;
+  if (this->_internal_has_struct_()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *struct__);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NamedStruct::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    NamedStruct::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NamedStruct::GetClassData() const { return &_class_data_; }
+
+void NamedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<NamedStruct *>(to)->MergeFrom(
+      static_cast<const NamedStruct &>(from));
+}
+
+
+void NamedStruct::MergeFrom(const NamedStruct& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.NamedStruct)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  names_.MergeFrom(from.names_);
+  if (from._internal_has_struct_()) {
+    _internal_mutable_struct_()->::substrait::Type_Struct::MergeFrom(from._internal_struct_());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void NamedStruct::CopyFrom(const NamedStruct& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.NamedStruct)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool NamedStruct::IsInitialized() const {
+  return true;
+}
+
+void NamedStruct::InternalSwap(NamedStruct* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  names_.InternalSwap(&other->names_);
+  swap(struct__, other->struct__);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata NamedStruct::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once,
+      file_level_metadata_substrait_2ftype_2eproto[24]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::substrait::Type_Boolean* Arena::CreateMaybeMessage< ::substrait::Type_Boolean >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_Boolean >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_I8* Arena::CreateMaybeMessage< ::substrait::Type_I8 >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_I8 >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_I16* Arena::CreateMaybeMessage< ::substrait::Type_I16 >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_I16 >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_I32* Arena::CreateMaybeMessage< ::substrait::Type_I32 >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_I32 >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_I64* Arena::CreateMaybeMessage< ::substrait::Type_I64 >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_I64 >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_FP32* Arena::CreateMaybeMessage< ::substrait::Type_FP32 >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_FP32 >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_FP64* Arena::CreateMaybeMessage< ::substrait::Type_FP64 >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_FP64 >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_String* Arena::CreateMaybeMessage< ::substrait::Type_String >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_String >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_Binary* Arena::CreateMaybeMessage< ::substrait::Type_Binary >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_Binary >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_Timestamp* Arena::CreateMaybeMessage< ::substrait::Type_Timestamp >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_Timestamp >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_Date* Arena::CreateMaybeMessage< ::substrait::Type_Date >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_Date >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_Time* Arena::CreateMaybeMessage< ::substrait::Type_Time >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_Time >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_TimestampTZ* Arena::CreateMaybeMessage< ::substrait::Type_TimestampTZ >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_TimestampTZ >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_IntervalYear* Arena::CreateMaybeMessage< ::substrait::Type_IntervalYear >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_IntervalYear >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_IntervalDay* Arena::CreateMaybeMessage< ::substrait::Type_IntervalDay >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_IntervalDay >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_UUID* Arena::CreateMaybeMessage< ::substrait::Type_UUID >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_UUID >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_FixedChar* Arena::CreateMaybeMessage< ::substrait::Type_FixedChar >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_FixedChar >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_VarChar* Arena::CreateMaybeMessage< ::substrait::Type_VarChar >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_VarChar >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_FixedBinary* Arena::CreateMaybeMessage< ::substrait::Type_FixedBinary >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_FixedBinary >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_Decimal* Arena::CreateMaybeMessage< ::substrait::Type_Decimal >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_Decimal >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_Struct* Arena::CreateMaybeMessage< ::substrait::Type_Struct >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_Struct >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_List* Arena::CreateMaybeMessage< ::substrait::Type_List >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_List >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type_Map* Arena::CreateMaybeMessage< ::substrait::Type_Map >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type_Map >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::Type* Arena::CreateMaybeMessage< ::substrait::Type >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::Type >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::NamedStruct* Arena::CreateMaybeMessage< ::substrait::NamedStruct >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::NamedStruct >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/cpp/src/generated/substrait/type.pb.h b/cpp/src/generated/substrait/type.pb.h
new file mode 100644
index 000000000000..b528e2f1b56a
--- /dev/null
+++ b/cpp/src/generated/substrait/type.pb.h
@@ -0,0 +1,8265 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/type.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3019000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3019003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_substrait_2ftype_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_substrait_2ftype_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[25]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_2eproto;
+namespace substrait {
+class NamedStruct;
+struct NamedStructDefaultTypeInternal;
+extern NamedStructDefaultTypeInternal _NamedStruct_default_instance_;
+class Type;
+struct TypeDefaultTypeInternal;
+extern TypeDefaultTypeInternal _Type_default_instance_;
+class Type_Binary;
+struct Type_BinaryDefaultTypeInternal;
+extern Type_BinaryDefaultTypeInternal _Type_Binary_default_instance_;
+class Type_Boolean;
+struct Type_BooleanDefaultTypeInternal;
+extern Type_BooleanDefaultTypeInternal _Type_Boolean_default_instance_;
+class Type_Date;
+struct Type_DateDefaultTypeInternal;
+extern Type_DateDefaultTypeInternal _Type_Date_default_instance_;
+class Type_Decimal;
+struct Type_DecimalDefaultTypeInternal;
+extern Type_DecimalDefaultTypeInternal _Type_Decimal_default_instance_;
+class Type_FP32;
+struct Type_FP32DefaultTypeInternal;
+extern Type_FP32DefaultTypeInternal _Type_FP32_default_instance_;
+class Type_FP64;
+struct Type_FP64DefaultTypeInternal;
+extern Type_FP64DefaultTypeInternal _Type_FP64_default_instance_;
+class Type_FixedBinary;
+struct Type_FixedBinaryDefaultTypeInternal;
+extern Type_FixedBinaryDefaultTypeInternal _Type_FixedBinary_default_instance_;
+class Type_FixedChar;
+struct Type_FixedCharDefaultTypeInternal;
+extern Type_FixedCharDefaultTypeInternal _Type_FixedChar_default_instance_;
+class Type_I16;
+struct Type_I16DefaultTypeInternal;
+extern Type_I16DefaultTypeInternal _Type_I16_default_instance_;
+class Type_I32;
+struct Type_I32DefaultTypeInternal;
+extern Type_I32DefaultTypeInternal _Type_I32_default_instance_;
+class Type_I64;
+struct Type_I64DefaultTypeInternal;
+extern Type_I64DefaultTypeInternal _Type_I64_default_instance_;
+class Type_I8;
+struct Type_I8DefaultTypeInternal;
+extern Type_I8DefaultTypeInternal _Type_I8_default_instance_;
+class Type_IntervalDay;
+struct Type_IntervalDayDefaultTypeInternal;
+extern Type_IntervalDayDefaultTypeInternal _Type_IntervalDay_default_instance_;
+class Type_IntervalYear;
+struct Type_IntervalYearDefaultTypeInternal;
+extern Type_IntervalYearDefaultTypeInternal _Type_IntervalYear_default_instance_;
+class Type_List;
+struct Type_ListDefaultTypeInternal;
+extern Type_ListDefaultTypeInternal _Type_List_default_instance_;
+class Type_Map;
+struct Type_MapDefaultTypeInternal;
+extern Type_MapDefaultTypeInternal _Type_Map_default_instance_;
+class Type_String;
+struct Type_StringDefaultTypeInternal;
+extern Type_StringDefaultTypeInternal _Type_String_default_instance_;
+class Type_Struct;
+struct Type_StructDefaultTypeInternal;
+extern Type_StructDefaultTypeInternal _Type_Struct_default_instance_;
+class Type_Time;
+struct Type_TimeDefaultTypeInternal;
+extern Type_TimeDefaultTypeInternal _Type_Time_default_instance_;
+class Type_Timestamp;
+struct Type_TimestampDefaultTypeInternal;
+extern Type_TimestampDefaultTypeInternal _Type_Timestamp_default_instance_;
+class Type_TimestampTZ;
+struct Type_TimestampTZDefaultTypeInternal;
+extern Type_TimestampTZDefaultTypeInternal _Type_TimestampTZ_default_instance_;
+class Type_UUID;
+struct Type_UUIDDefaultTypeInternal;
+extern Type_UUIDDefaultTypeInternal _Type_UUID_default_instance_;
+class Type_VarChar;
+struct Type_VarCharDefaultTypeInternal;
+extern Type_VarCharDefaultTypeInternal _Type_VarChar_default_instance_;
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> ::substrait::NamedStruct* Arena::CreateMaybeMessage<::substrait::NamedStruct>(Arena*);
+template<> ::substrait::Type* Arena::CreateMaybeMessage<::substrait::Type>(Arena*);
+template<> ::substrait::Type_Binary* Arena::CreateMaybeMessage<::substrait::Type_Binary>(Arena*);
+template<> ::substrait::Type_Boolean* Arena::CreateMaybeMessage<::substrait::Type_Boolean>(Arena*);
+template<> ::substrait::Type_Date* Arena::CreateMaybeMessage<::substrait::Type_Date>(Arena*);
+template<> ::substrait::Type_Decimal* Arena::CreateMaybeMessage<::substrait::Type_Decimal>(Arena*);
+template<> ::substrait::Type_FP32* Arena::CreateMaybeMessage<::substrait::Type_FP32>(Arena*);
+template<> ::substrait::Type_FP64* Arena::CreateMaybeMessage<::substrait::Type_FP64>(Arena*);
+template<> ::substrait::Type_FixedBinary* Arena::CreateMaybeMessage<::substrait::Type_FixedBinary>(Arena*);
+template<> ::substrait::Type_FixedChar* Arena::CreateMaybeMessage<::substrait::Type_FixedChar>(Arena*);
+template<> ::substrait::Type_I16* Arena::CreateMaybeMessage<::substrait::Type_I16>(Arena*);
+template<> ::substrait::Type_I32* Arena::CreateMaybeMessage<::substrait::Type_I32>(Arena*);
+template<> ::substrait::Type_I64* Arena::CreateMaybeMessage<::substrait::Type_I64>(Arena*);
+template<> ::substrait::Type_I8* Arena::CreateMaybeMessage<::substrait::Type_I8>(Arena*);
+template<> ::substrait::Type_IntervalDay* Arena::CreateMaybeMessage<::substrait::Type_IntervalDay>(Arena*);
+template<> ::substrait::Type_IntervalYear* Arena::CreateMaybeMessage<::substrait::Type_IntervalYear>(Arena*);
+template<> ::substrait::Type_List* Arena::CreateMaybeMessage<::substrait::Type_List>(Arena*);
+template<> ::substrait::Type_Map* Arena::CreateMaybeMessage<::substrait::Type_Map>(Arena*);
+template<> ::substrait::Type_String* Arena::CreateMaybeMessage<::substrait::Type_String>(Arena*);
+template<> ::substrait::Type_Struct* Arena::CreateMaybeMessage<::substrait::Type_Struct>(Arena*);
+template<> ::substrait::Type_Time* Arena::CreateMaybeMessage<::substrait::Type_Time>(Arena*);
+template<> ::substrait::Type_Timestamp* Arena::CreateMaybeMessage<::substrait::Type_Timestamp>(Arena*);
+template<> ::substrait::Type_TimestampTZ* Arena::CreateMaybeMessage<::substrait::Type_TimestampTZ>(Arena*);
+template<> ::substrait::Type_UUID* Arena::CreateMaybeMessage<::substrait::Type_UUID>(Arena*);
+template<> ::substrait::Type_VarChar* Arena::CreateMaybeMessage<::substrait::Type_VarChar>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace substrait {
+
+enum Type_Nullability : int {
+  Type_Nullability_NULLABILITY_UNSPECIFIED = 0,
+  Type_Nullability_NULLABILITY_NULLABLE = 1,
+  Type_Nullability_NULLABILITY_REQUIRED = 2,
+  Type_Nullability_Type_Nullability_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  Type_Nullability_Type_Nullability_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool Type_Nullability_IsValid(int value);
+constexpr Type_Nullability Type_Nullability_Nullability_MIN = Type_Nullability_NULLABILITY_UNSPECIFIED;
+constexpr Type_Nullability Type_Nullability_Nullability_MAX = Type_Nullability_NULLABILITY_REQUIRED;
+constexpr int Type_Nullability_Nullability_ARRAYSIZE = Type_Nullability_Nullability_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_Nullability_descriptor();
+template<typename T>
+inline const std::string& Type_Nullability_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Type_Nullability>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Type_Nullability_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Type_Nullability_descriptor(), enum_t_value);
+}
+inline bool Type_Nullability_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Type_Nullability* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Type_Nullability>(
+    Type_Nullability_descriptor(), name, value);
+}
+// ===================================================================
+
+class Type_Boolean final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Boolean) */ {
+ public:
+  inline Type_Boolean() : Type_Boolean(nullptr) {}
+  ~Type_Boolean() override;
+  explicit constexpr Type_Boolean(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_Boolean(const Type_Boolean& from);
+  Type_Boolean(Type_Boolean&& from) noexcept
+    : Type_Boolean() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_Boolean& operator=(const Type_Boolean& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_Boolean& operator=(Type_Boolean&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_Boolean& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_Boolean* internal_default_instance() {
+    return reinterpret_cast<const Type_Boolean*>(
+               &_Type_Boolean_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Type_Boolean& a, Type_Boolean& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_Boolean* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_Boolean* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_Boolean* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_Boolean>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_Boolean& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_Boolean& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_Boolean* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.Boolean";
+  }
+  protected:
+  explicit Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.Boolean)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_I8 final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I8) */ {
+ public:
+  inline Type_I8() : Type_I8(nullptr) {}
+  ~Type_I8() override;
+  explicit constexpr Type_I8(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_I8(const Type_I8& from);
+  Type_I8(Type_I8&& from) noexcept
+    : Type_I8() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_I8& operator=(const Type_I8& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_I8& operator=(Type_I8&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_I8& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_I8* internal_default_instance() {
+    return reinterpret_cast<const Type_I8*>(
+               &_Type_I8_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(Type_I8& a, Type_I8& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_I8* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_I8* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_I8* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_I8>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_I8& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_I8& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_I8* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.I8";
+  }
+  protected:
+  explicit Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.I8)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_I16 final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I16) */ {
+ public:
+  inline Type_I16() : Type_I16(nullptr) {}
+  ~Type_I16() override;
+  explicit constexpr Type_I16(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_I16(const Type_I16& from);
+  Type_I16(Type_I16&& from) noexcept
+    : Type_I16() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_I16& operator=(const Type_I16& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_I16& operator=(Type_I16&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_I16& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_I16* internal_default_instance() {
+    return reinterpret_cast<const Type_I16*>(
+               &_Type_I16_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(Type_I16& a, Type_I16& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_I16* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_I16* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_I16* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_I16>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_I16& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_I16& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_I16* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.I16";
+  }
+  protected:
+  explicit Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.I16)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_I32 final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I32) */ {
+ public:
+  inline Type_I32() : Type_I32(nullptr) {}
+  ~Type_I32() override;
+  explicit constexpr Type_I32(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_I32(const Type_I32& from);
+  Type_I32(Type_I32&& from) noexcept
+    : Type_I32() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_I32& operator=(const Type_I32& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_I32& operator=(Type_I32&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_I32& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_I32* internal_default_instance() {
+    return reinterpret_cast<const Type_I32*>(
+               &_Type_I32_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(Type_I32& a, Type_I32& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_I32* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_I32* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_I32* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_I32>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_I32& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_I32& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_I32* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.I32";
+  }
+  protected:
+  explicit Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.I32)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_I64 final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I64) */ {
+ public:
+  inline Type_I64() : Type_I64(nullptr) {}
+  ~Type_I64() override;
+  explicit constexpr Type_I64(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_I64(const Type_I64& from);
+  Type_I64(Type_I64&& from) noexcept
+    : Type_I64() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_I64& operator=(const Type_I64& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_I64& operator=(Type_I64&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_I64& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_I64* internal_default_instance() {
+    return reinterpret_cast<const Type_I64*>(
+               &_Type_I64_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(Type_I64& a, Type_I64& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_I64* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_I64* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_I64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_I64>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_I64& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_I64& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_I64* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.I64";
+  }
+  protected:
+  explicit Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.I64)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_FP32 final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FP32) */ {
+ public:
+  inline Type_FP32() : Type_FP32(nullptr) {}
+  ~Type_FP32() override;
+  explicit constexpr Type_FP32(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_FP32(const Type_FP32& from);
+  Type_FP32(Type_FP32&& from) noexcept
+    : Type_FP32() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_FP32& operator=(const Type_FP32& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_FP32& operator=(Type_FP32&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_FP32& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_FP32* internal_default_instance() {
+    return reinterpret_cast<const Type_FP32*>(
+               &_Type_FP32_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(Type_FP32& a, Type_FP32& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_FP32* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_FP32* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_FP32* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_FP32>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_FP32& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_FP32& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_FP32* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.FP32";
+  }
+  protected:
+  explicit Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.FP32)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_FP64 final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FP64) */ {
+ public:
+  inline Type_FP64() : Type_FP64(nullptr) {}
+  ~Type_FP64() override;
+  explicit constexpr Type_FP64(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_FP64(const Type_FP64& from);
+  Type_FP64(Type_FP64&& from) noexcept
+    : Type_FP64() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_FP64& operator=(const Type_FP64& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_FP64& operator=(Type_FP64&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_FP64& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_FP64* internal_default_instance() {
+    return reinterpret_cast<const Type_FP64*>(
+               &_Type_FP64_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(Type_FP64& a, Type_FP64& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_FP64* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_FP64* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_FP64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_FP64>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_FP64& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_FP64& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_FP64* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.FP64";
+  }
+  protected:
+  explicit Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.FP64)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_String final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.String) */ {
+ public:
+  inline Type_String() : Type_String(nullptr) {}
+  ~Type_String() override;
+  explicit constexpr Type_String(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_String(const Type_String& from);
+  Type_String(Type_String&& from) noexcept
+    : Type_String() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_String& operator=(const Type_String& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_String& operator=(Type_String&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_String& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_String* internal_default_instance() {
+    return reinterpret_cast<const Type_String*>(
+               &_Type_String_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(Type_String& a, Type_String& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_String* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_String* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_String* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_String>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_String& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_String& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_String* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.String";
+  }
+  protected:
+  explicit Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.String)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_Binary final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Binary) */ {
+ public:
+  inline Type_Binary() : Type_Binary(nullptr) {}
+  ~Type_Binary() override;
+  explicit constexpr Type_Binary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_Binary(const Type_Binary& from);
+  Type_Binary(Type_Binary&& from) noexcept
+    : Type_Binary() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_Binary& operator=(const Type_Binary& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_Binary& operator=(Type_Binary&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_Binary& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_Binary* internal_default_instance() {
+    return reinterpret_cast<const Type_Binary*>(
+               &_Type_Binary_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(Type_Binary& a, Type_Binary& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_Binary* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_Binary* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_Binary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_Binary>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_Binary& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_Binary& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_Binary* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.Binary";
+  }
+  protected:
+  explicit Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.Binary)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_Timestamp final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Timestamp) */ {
+ public:
+  inline Type_Timestamp() : Type_Timestamp(nullptr) {}
+  ~Type_Timestamp() override;
+  explicit constexpr Type_Timestamp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_Timestamp(const Type_Timestamp& from);
+  Type_Timestamp(Type_Timestamp&& from) noexcept
+    : Type_Timestamp() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_Timestamp& operator=(const Type_Timestamp& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_Timestamp& operator=(Type_Timestamp&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_Timestamp& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_Timestamp* internal_default_instance() {
+    return reinterpret_cast<const Type_Timestamp*>(
+               &_Type_Timestamp_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(Type_Timestamp& a, Type_Timestamp& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_Timestamp* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_Timestamp* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_Timestamp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_Timestamp>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_Timestamp& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_Timestamp& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_Timestamp* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.Timestamp";
+  }
+  protected:
+  explicit Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.Timestamp)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_Date final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Date) */ {
+ public:
+  inline Type_Date() : Type_Date(nullptr) {}
+  ~Type_Date() override;
+  explicit constexpr Type_Date(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_Date(const Type_Date& from);
+  Type_Date(Type_Date&& from) noexcept
+    : Type_Date() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_Date& operator=(const Type_Date& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_Date& operator=(Type_Date&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_Date& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_Date* internal_default_instance() {
+    return reinterpret_cast<const Type_Date*>(
+               &_Type_Date_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(Type_Date& a, Type_Date& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_Date* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_Date* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_Date* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_Date>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_Date& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_Date& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_Date* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.Date";
+  }
+  protected:
+  explicit Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.Date)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_Time final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Time) */ {
+ public:
+  inline Type_Time() : Type_Time(nullptr) {}
+  ~Type_Time() override;
+  explicit constexpr Type_Time(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_Time(const Type_Time& from);
+  Type_Time(Type_Time&& from) noexcept
+    : Type_Time() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_Time& operator=(const Type_Time& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_Time& operator=(Type_Time&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_Time& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_Time* internal_default_instance() {
+    return reinterpret_cast<const Type_Time*>(
+               &_Type_Time_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(Type_Time& a, Type_Time& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_Time* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_Time* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_Time* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_Time>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_Time& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_Time& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_Time* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.Time";
+  }
+  protected:
+  explicit Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.Time)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_TimestampTZ final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.TimestampTZ) */ {
+ public:
+  inline Type_TimestampTZ() : Type_TimestampTZ(nullptr) {}
+  ~Type_TimestampTZ() override;
+  explicit constexpr Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_TimestampTZ(const Type_TimestampTZ& from);
+  Type_TimestampTZ(Type_TimestampTZ&& from) noexcept
+    : Type_TimestampTZ() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_TimestampTZ& operator=(const Type_TimestampTZ& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_TimestampTZ& operator=(Type_TimestampTZ&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_TimestampTZ& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_TimestampTZ* internal_default_instance() {
+    return reinterpret_cast<const Type_TimestampTZ*>(
+               &_Type_TimestampTZ_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(Type_TimestampTZ& a, Type_TimestampTZ& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_TimestampTZ* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_TimestampTZ* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_TimestampTZ* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_TimestampTZ>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_TimestampTZ& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_TimestampTZ& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_TimestampTZ* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.TimestampTZ";
+  }
+  protected:
+  explicit Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.TimestampTZ)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_IntervalYear final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.IntervalYear) */ {
+ public:
+  inline Type_IntervalYear() : Type_IntervalYear(nullptr) {}
+  ~Type_IntervalYear() override;
+  explicit constexpr Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_IntervalYear(const Type_IntervalYear& from);
+  Type_IntervalYear(Type_IntervalYear&& from) noexcept
+    : Type_IntervalYear() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_IntervalYear& operator=(const Type_IntervalYear& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_IntervalYear& operator=(Type_IntervalYear&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_IntervalYear& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_IntervalYear* internal_default_instance() {
+    return reinterpret_cast<const Type_IntervalYear*>(
+               &_Type_IntervalYear_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(Type_IntervalYear& a, Type_IntervalYear& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_IntervalYear* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_IntervalYear* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_IntervalYear* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_IntervalYear>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_IntervalYear& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_IntervalYear& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_IntervalYear* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.IntervalYear";
+  }
+  protected:
+  explicit Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.IntervalYear)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_IntervalDay final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.IntervalDay) */ {
+ public:
+  inline Type_IntervalDay() : Type_IntervalDay(nullptr) {}
+  ~Type_IntervalDay() override;
+  explicit constexpr Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_IntervalDay(const Type_IntervalDay& from);
+  Type_IntervalDay(Type_IntervalDay&& from) noexcept
+    : Type_IntervalDay() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_IntervalDay& operator=(const Type_IntervalDay& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_IntervalDay& operator=(Type_IntervalDay&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_IntervalDay& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_IntervalDay* internal_default_instance() {
+    return reinterpret_cast<const Type_IntervalDay*>(
+               &_Type_IntervalDay_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(Type_IntervalDay& a, Type_IntervalDay& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_IntervalDay* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_IntervalDay* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_IntervalDay* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_IntervalDay>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_IntervalDay& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_IntervalDay& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_IntervalDay* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.IntervalDay";
+  }
+  protected:
+  explicit Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.IntervalDay)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_UUID final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.UUID) */ {
+ public:
+  inline Type_UUID() : Type_UUID(nullptr) {}
+  ~Type_UUID() override;
+  explicit constexpr Type_UUID(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_UUID(const Type_UUID& from);
+  Type_UUID(Type_UUID&& from) noexcept
+    : Type_UUID() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_UUID& operator=(const Type_UUID& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_UUID& operator=(Type_UUID&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_UUID& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_UUID* internal_default_instance() {
+    return reinterpret_cast<const Type_UUID*>(
+               &_Type_UUID_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(Type_UUID& a, Type_UUID& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_UUID* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_UUID* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_UUID* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_UUID>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_UUID& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_UUID& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_UUID* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.UUID";
+  }
+  protected:
+  explicit Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeVariationReferenceFieldNumber = 1,
+    kNullabilityFieldNumber = 2,
+  };
+  // uint32 type_variation_reference = 1;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 2;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.UUID)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_FixedChar final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FixedChar) */ {
+ public:
+  inline Type_FixedChar() : Type_FixedChar(nullptr) {}
+  ~Type_FixedChar() override;
+  explicit constexpr Type_FixedChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_FixedChar(const Type_FixedChar& from);
+  Type_FixedChar(Type_FixedChar&& from) noexcept
+    : Type_FixedChar() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_FixedChar& operator=(const Type_FixedChar& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_FixedChar& operator=(Type_FixedChar&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_FixedChar& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_FixedChar* internal_default_instance() {
+    return reinterpret_cast<const Type_FixedChar*>(
+               &_Type_FixedChar_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(Type_FixedChar& a, Type_FixedChar& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_FixedChar* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_FixedChar* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_FixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_FixedChar>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_FixedChar& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_FixedChar& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_FixedChar* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.FixedChar";
+  }
+  protected:
+  explicit Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLengthFieldNumber = 1,
+    kTypeVariationReferenceFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // int32 length = 1;
+  void clear_length();
+  int32_t length() const;
+  void set_length(int32_t value);
+  private:
+  int32_t _internal_length() const;
+  void _internal_set_length(int32_t value);
+  public:
+
+  // uint32 type_variation_reference = 2;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.FixedChar)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int32_t length_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_VarChar final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.VarChar) */ {
+ public:
+  inline Type_VarChar() : Type_VarChar(nullptr) {}
+  ~Type_VarChar() override;
+  explicit constexpr Type_VarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_VarChar(const Type_VarChar& from);
+  Type_VarChar(Type_VarChar&& from) noexcept
+    : Type_VarChar() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_VarChar& operator=(const Type_VarChar& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_VarChar& operator=(Type_VarChar&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_VarChar& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_VarChar* internal_default_instance() {
+    return reinterpret_cast<const Type_VarChar*>(
+               &_Type_VarChar_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(Type_VarChar& a, Type_VarChar& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_VarChar* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_VarChar* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_VarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_VarChar>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_VarChar& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_VarChar& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_VarChar* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.VarChar";
+  }
+  protected:
+  explicit Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLengthFieldNumber = 1,
+    kTypeVariationReferenceFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // int32 length = 1;
+  void clear_length();
+  int32_t length() const;
+  void set_length(int32_t value);
+  private:
+  int32_t _internal_length() const;
+  void _internal_set_length(int32_t value);
+  public:
+
+  // uint32 type_variation_reference = 2;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.VarChar)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int32_t length_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_FixedBinary final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FixedBinary) */ {
+ public:
+  inline Type_FixedBinary() : Type_FixedBinary(nullptr) {}
+  ~Type_FixedBinary() override;
+  explicit constexpr Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_FixedBinary(const Type_FixedBinary& from);
+  Type_FixedBinary(Type_FixedBinary&& from) noexcept
+    : Type_FixedBinary() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_FixedBinary& operator=(const Type_FixedBinary& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_FixedBinary& operator=(Type_FixedBinary&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_FixedBinary& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_FixedBinary* internal_default_instance() {
+    return reinterpret_cast<const Type_FixedBinary*>(
+               &_Type_FixedBinary_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(Type_FixedBinary& a, Type_FixedBinary& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_FixedBinary* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_FixedBinary* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_FixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_FixedBinary>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_FixedBinary& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_FixedBinary& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_FixedBinary* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.FixedBinary";
+  }
+  protected:
+  explicit Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLengthFieldNumber = 1,
+    kTypeVariationReferenceFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // int32 length = 1;
+  void clear_length();
+  int32_t length() const;
+  void set_length(int32_t value);
+  private:
+  int32_t _internal_length() const;
+  void _internal_set_length(int32_t value);
+  public:
+
+  // uint32 type_variation_reference = 2;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.FixedBinary)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int32_t length_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_Decimal final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Decimal) */ {
+ public:
+  inline Type_Decimal() : Type_Decimal(nullptr) {}
+  ~Type_Decimal() override;
+  explicit constexpr Type_Decimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_Decimal(const Type_Decimal& from);
+  Type_Decimal(Type_Decimal&& from) noexcept
+    : Type_Decimal() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_Decimal& operator=(const Type_Decimal& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_Decimal& operator=(Type_Decimal&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_Decimal& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_Decimal* internal_default_instance() {
+    return reinterpret_cast<const Type_Decimal*>(
+               &_Type_Decimal_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  friend void swap(Type_Decimal& a, Type_Decimal& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_Decimal* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_Decimal* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_Decimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_Decimal>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_Decimal& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_Decimal& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_Decimal* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.Decimal";
+  }
+  protected:
+  explicit Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kScaleFieldNumber = 1,
+    kPrecisionFieldNumber = 2,
+    kTypeVariationReferenceFieldNumber = 3,
+    kNullabilityFieldNumber = 4,
+  };
+  // int32 scale = 1;
+  void clear_scale();
+  int32_t scale() const;
+  void set_scale(int32_t value);
+  private:
+  int32_t _internal_scale() const;
+  void _internal_set_scale(int32_t value);
+  public:
+
+  // int32 precision = 2;
+  void clear_precision();
+  int32_t precision() const;
+  void set_precision(int32_t value);
+  private:
+  int32_t _internal_precision() const;
+  void _internal_set_precision(int32_t value);
+  public:
+
+  // uint32 type_variation_reference = 3;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 4;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.Decimal)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  int32_t scale_;
+  int32_t precision_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_Struct final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Struct) */ {
+ public:
+  inline Type_Struct() : Type_Struct(nullptr) {}
+  ~Type_Struct() override;
+  explicit constexpr Type_Struct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_Struct(const Type_Struct& from);
+  Type_Struct(Type_Struct&& from) noexcept
+    : Type_Struct() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_Struct& operator=(const Type_Struct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_Struct& operator=(Type_Struct&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_Struct& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_Struct* internal_default_instance() {
+    return reinterpret_cast<const Type_Struct*>(
+               &_Type_Struct_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  friend void swap(Type_Struct& a, Type_Struct& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_Struct* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_Struct* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_Struct>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_Struct& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_Struct& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_Struct* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.Struct";
+  }
+  protected:
+  explicit Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypesFieldNumber = 1,
+    kTypeVariationReferenceFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // repeated .substrait.Type types = 1;
+  int types_size() const;
+  private:
+  int _internal_types_size() const;
+  public:
+  void clear_types();
+  ::substrait::Type* mutable_types(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >*
+      mutable_types();
+  private:
+  const ::substrait::Type& _internal_types(int index) const;
+  ::substrait::Type* _internal_add_types();
+  public:
+  const ::substrait::Type& types(int index) const;
+  ::substrait::Type* add_types();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >&
+      types() const;
+
+  // uint32 type_variation_reference = 2;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.Struct)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type > types_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_List final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.List) */ {
+ public:
+  inline Type_List() : Type_List(nullptr) {}
+  ~Type_List() override;
+  explicit constexpr Type_List(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_List(const Type_List& from);
+  Type_List(Type_List&& from) noexcept
+    : Type_List() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_List& operator=(const Type_List& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_List& operator=(Type_List&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_List& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_List* internal_default_instance() {
+    return reinterpret_cast<const Type_List*>(
+               &_Type_List_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    21;
+
+  friend void swap(Type_List& a, Type_List& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_List* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_List* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_List>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_List& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_List& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_List* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.List";
+  }
+  protected:
+  explicit Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeFieldNumber = 1,
+    kTypeVariationReferenceFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // .substrait.Type type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  const ::substrait::Type& type() const;
+  PROTOBUF_NODISCARD ::substrait::Type* release_type();
+  ::substrait::Type* mutable_type();
+  void set_allocated_type(::substrait::Type* type);
+  private:
+  const ::substrait::Type& _internal_type() const;
+  ::substrait::Type* _internal_mutable_type();
+  public:
+  void unsafe_arena_set_allocated_type(
+      ::substrait::Type* type);
+  ::substrait::Type* unsafe_arena_release_type();
+
+  // uint32 type_variation_reference = 2;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.List)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Type* type_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type_Map final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Map) */ {
+ public:
+  inline Type_Map() : Type_Map(nullptr) {}
+  ~Type_Map() override;
+  explicit constexpr Type_Map(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type_Map(const Type_Map& from);
+  Type_Map(Type_Map&& from) noexcept
+    : Type_Map() {
+    *this = ::std::move(from);
+  }
+
+  inline Type_Map& operator=(const Type_Map& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type_Map& operator=(Type_Map&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type_Map& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const Type_Map* internal_default_instance() {
+    return reinterpret_cast<const Type_Map*>(
+               &_Type_Map_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    22;
+
+  friend void swap(Type_Map& a, Type_Map& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type_Map* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type_Map* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type_Map>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type_Map& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type_Map& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type_Map* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type.Map";
+  }
+  protected:
+  explicit Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+    kTypeVariationReferenceFieldNumber = 3,
+    kNullabilityFieldNumber = 4,
+  };
+  // .substrait.Type key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::substrait::Type& key() const;
+  PROTOBUF_NODISCARD ::substrait::Type* release_key();
+  ::substrait::Type* mutable_key();
+  void set_allocated_key(::substrait::Type* key);
+  private:
+  const ::substrait::Type& _internal_key() const;
+  ::substrait::Type* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::substrait::Type* key);
+  ::substrait::Type* unsafe_arena_release_key();
+
+  // .substrait.Type value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const ::substrait::Type& value() const;
+  PROTOBUF_NODISCARD ::substrait::Type* release_value();
+  ::substrait::Type* mutable_value();
+  void set_allocated_value(::substrait::Type* value);
+  private:
+  const ::substrait::Type& _internal_value() const;
+  ::substrait::Type* _internal_mutable_value();
+  public:
+  void unsafe_arena_set_allocated_value(
+      ::substrait::Type* value);
+  ::substrait::Type* unsafe_arena_release_value();
+
+  // uint32 type_variation_reference = 3;
+  void clear_type_variation_reference();
+  uint32_t type_variation_reference() const;
+  void set_type_variation_reference(uint32_t value);
+  private:
+  uint32_t _internal_type_variation_reference() const;
+  void _internal_set_type_variation_reference(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 4;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.Type.Map)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::Type* key_;
+  ::substrait::Type* value_;
+  uint32_t type_variation_reference_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Type final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type) */ {
+ public:
+  inline Type() : Type(nullptr) {}
+  ~Type() override;
+  explicit constexpr Type(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  Type(const Type& from);
+  Type(Type&& from) noexcept
+    : Type() {
+    *this = ::std::move(from);
+  }
+
+  inline Type& operator=(const Type& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Type& operator=(Type&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const Type& default_instance() {
+    return *internal_default_instance();
+  }
+  enum KindCase {
+    kBool = 1,
+    kI8 = 2,
+    kI16 = 3,
+    kI32 = 5,
+    kI64 = 7,
+    kFp32 = 10,
+    kFp64 = 11,
+    kString = 12,
+    kBinary = 13,
+    kTimestamp = 14,
+    kDate = 16,
+    kTime = 17,
+    kIntervalYear = 19,
+    kIntervalDay = 20,
+    kTimestampTz = 29,
+    kUuid = 32,
+    kFixedChar = 21,
+    kVarchar = 22,
+    kFixedBinary = 23,
+    kDecimal = 24,
+    kStruct = 25,
+    kList = 27,
+    kMap = 28,
+    kUserDefinedTypeReference = 31,
+    KIND_NOT_SET = 0,
+  };
+
+  static inline const Type* internal_default_instance() {
+    return reinterpret_cast<const Type*>(
+               &_Type_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    23;
+
+  friend void swap(Type& a, Type& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Type* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(Type* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  Type* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<Type>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const Type& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const Type& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Type* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.Type";
+  }
+  protected:
+  explicit Type(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef Type_Boolean Boolean;
+  typedef Type_I8 I8;
+  typedef Type_I16 I16;
+  typedef Type_I32 I32;
+  typedef Type_I64 I64;
+  typedef Type_FP32 FP32;
+  typedef Type_FP64 FP64;
+  typedef Type_String String;
+  typedef Type_Binary Binary;
+  typedef Type_Timestamp Timestamp;
+  typedef Type_Date Date;
+  typedef Type_Time Time;
+  typedef Type_TimestampTZ TimestampTZ;
+  typedef Type_IntervalYear IntervalYear;
+  typedef Type_IntervalDay IntervalDay;
+  typedef Type_UUID UUID;
+  typedef Type_FixedChar FixedChar;
+  typedef Type_VarChar VarChar;
+  typedef Type_FixedBinary FixedBinary;
+  typedef Type_Decimal Decimal;
+  typedef Type_Struct Struct;
+  typedef Type_List List;
+  typedef Type_Map Map;
+
+  typedef Type_Nullability Nullability;
+  static constexpr Nullability NULLABILITY_UNSPECIFIED =
+    Type_Nullability_NULLABILITY_UNSPECIFIED;
+  static constexpr Nullability NULLABILITY_NULLABLE =
+    Type_Nullability_NULLABILITY_NULLABLE;
+  static constexpr Nullability NULLABILITY_REQUIRED =
+    Type_Nullability_NULLABILITY_REQUIRED;
+  static inline bool Nullability_IsValid(int value) {
+    return Type_Nullability_IsValid(value);
+  }
+  static constexpr Nullability Nullability_MIN =
+    Type_Nullability_Nullability_MIN;
+  static constexpr Nullability Nullability_MAX =
+    Type_Nullability_Nullability_MAX;
+  static constexpr int Nullability_ARRAYSIZE =
+    Type_Nullability_Nullability_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Nullability_descriptor() {
+    return Type_Nullability_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Nullability_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Nullability>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Nullability_Name.");
+    return Type_Nullability_Name(enum_t_value);
+  }
+  static inline bool Nullability_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Nullability* value) {
+    return Type_Nullability_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBoolFieldNumber = 1,
+    kI8FieldNumber = 2,
+    kI16FieldNumber = 3,
+    kI32FieldNumber = 5,
+    kI64FieldNumber = 7,
+    kFp32FieldNumber = 10,
+    kFp64FieldNumber = 11,
+    kStringFieldNumber = 12,
+    kBinaryFieldNumber = 13,
+    kTimestampFieldNumber = 14,
+    kDateFieldNumber = 16,
+    kTimeFieldNumber = 17,
+    kIntervalYearFieldNumber = 19,
+    kIntervalDayFieldNumber = 20,
+    kTimestampTzFieldNumber = 29,
+    kUuidFieldNumber = 32,
+    kFixedCharFieldNumber = 21,
+    kVarcharFieldNumber = 22,
+    kFixedBinaryFieldNumber = 23,
+    kDecimalFieldNumber = 24,
+    kStructFieldNumber = 25,
+    kListFieldNumber = 27,
+    kMapFieldNumber = 28,
+    kUserDefinedTypeReferenceFieldNumber = 31,
+  };
+  // .substrait.Type.Boolean bool = 1;
+  bool has_bool_() const;
+  private:
+  bool _internal_has_bool_() const;
+  public:
+  void clear_bool_();
+  const ::substrait::Type_Boolean& bool_() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Boolean* release_bool_();
+  ::substrait::Type_Boolean* mutable_bool_();
+  void set_allocated_bool_(::substrait::Type_Boolean* bool_);
+  private:
+  const ::substrait::Type_Boolean& _internal_bool_() const;
+  ::substrait::Type_Boolean* _internal_mutable_bool_();
+  public:
+  void unsafe_arena_set_allocated_bool_(
+      ::substrait::Type_Boolean* bool_);
+  ::substrait::Type_Boolean* unsafe_arena_release_bool_();
+
+  // .substrait.Type.I8 i8 = 2;
+  bool has_i8() const;
+  private:
+  bool _internal_has_i8() const;
+  public:
+  void clear_i8();
+  const ::substrait::Type_I8& i8() const;
+  PROTOBUF_NODISCARD ::substrait::Type_I8* release_i8();
+  ::substrait::Type_I8* mutable_i8();
+  void set_allocated_i8(::substrait::Type_I8* i8);
+  private:
+  const ::substrait::Type_I8& _internal_i8() const;
+  ::substrait::Type_I8* _internal_mutable_i8();
+  public:
+  void unsafe_arena_set_allocated_i8(
+      ::substrait::Type_I8* i8);
+  ::substrait::Type_I8* unsafe_arena_release_i8();
+
+  // .substrait.Type.I16 i16 = 3;
+  bool has_i16() const;
+  private:
+  bool _internal_has_i16() const;
+  public:
+  void clear_i16();
+  const ::substrait::Type_I16& i16() const;
+  PROTOBUF_NODISCARD ::substrait::Type_I16* release_i16();
+  ::substrait::Type_I16* mutable_i16();
+  void set_allocated_i16(::substrait::Type_I16* i16);
+  private:
+  const ::substrait::Type_I16& _internal_i16() const;
+  ::substrait::Type_I16* _internal_mutable_i16();
+  public:
+  void unsafe_arena_set_allocated_i16(
+      ::substrait::Type_I16* i16);
+  ::substrait::Type_I16* unsafe_arena_release_i16();
+
+  // .substrait.Type.I32 i32 = 5;
+  bool has_i32() const;
+  private:
+  bool _internal_has_i32() const;
+  public:
+  void clear_i32();
+  const ::substrait::Type_I32& i32() const;
+  PROTOBUF_NODISCARD ::substrait::Type_I32* release_i32();
+  ::substrait::Type_I32* mutable_i32();
+  void set_allocated_i32(::substrait::Type_I32* i32);
+  private:
+  const ::substrait::Type_I32& _internal_i32() const;
+  ::substrait::Type_I32* _internal_mutable_i32();
+  public:
+  void unsafe_arena_set_allocated_i32(
+      ::substrait::Type_I32* i32);
+  ::substrait::Type_I32* unsafe_arena_release_i32();
+
+  // .substrait.Type.I64 i64 = 7;
+  bool has_i64() const;
+  private:
+  bool _internal_has_i64() const;
+  public:
+  void clear_i64();
+  const ::substrait::Type_I64& i64() const;
+  PROTOBUF_NODISCARD ::substrait::Type_I64* release_i64();
+  ::substrait::Type_I64* mutable_i64();
+  void set_allocated_i64(::substrait::Type_I64* i64);
+  private:
+  const ::substrait::Type_I64& _internal_i64() const;
+  ::substrait::Type_I64* _internal_mutable_i64();
+  public:
+  void unsafe_arena_set_allocated_i64(
+      ::substrait::Type_I64* i64);
+  ::substrait::Type_I64* unsafe_arena_release_i64();
+
+  // .substrait.Type.FP32 fp32 = 10;
+  bool has_fp32() const;
+  private:
+  bool _internal_has_fp32() const;
+  public:
+  void clear_fp32();
+  const ::substrait::Type_FP32& fp32() const;
+  PROTOBUF_NODISCARD ::substrait::Type_FP32* release_fp32();
+  ::substrait::Type_FP32* mutable_fp32();
+  void set_allocated_fp32(::substrait::Type_FP32* fp32);
+  private:
+  const ::substrait::Type_FP32& _internal_fp32() const;
+  ::substrait::Type_FP32* _internal_mutable_fp32();
+  public:
+  void unsafe_arena_set_allocated_fp32(
+      ::substrait::Type_FP32* fp32);
+  ::substrait::Type_FP32* unsafe_arena_release_fp32();
+
+  // .substrait.Type.FP64 fp64 = 11;
+  bool has_fp64() const;
+  private:
+  bool _internal_has_fp64() const;
+  public:
+  void clear_fp64();
+  const ::substrait::Type_FP64& fp64() const;
+  PROTOBUF_NODISCARD ::substrait::Type_FP64* release_fp64();
+  ::substrait::Type_FP64* mutable_fp64();
+  void set_allocated_fp64(::substrait::Type_FP64* fp64);
+  private:
+  const ::substrait::Type_FP64& _internal_fp64() const;
+  ::substrait::Type_FP64* _internal_mutable_fp64();
+  public:
+  void unsafe_arena_set_allocated_fp64(
+      ::substrait::Type_FP64* fp64);
+  ::substrait::Type_FP64* unsafe_arena_release_fp64();
+
+  // .substrait.Type.String string = 12;
+  bool has_string() const;
+  private:
+  bool _internal_has_string() const;
+  public:
+  void clear_string();
+  const ::substrait::Type_String& string() const;
+  PROTOBUF_NODISCARD ::substrait::Type_String* release_string();
+  ::substrait::Type_String* mutable_string();
+  void set_allocated_string(::substrait::Type_String* string);
+  private:
+  const ::substrait::Type_String& _internal_string() const;
+  ::substrait::Type_String* _internal_mutable_string();
+  public:
+  void unsafe_arena_set_allocated_string(
+      ::substrait::Type_String* string);
+  ::substrait::Type_String* unsafe_arena_release_string();
+
+  // .substrait.Type.Binary binary = 13;
+  bool has_binary() const;
+  private:
+  bool _internal_has_binary() const;
+  public:
+  void clear_binary();
+  const ::substrait::Type_Binary& binary() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Binary* release_binary();
+  ::substrait::Type_Binary* mutable_binary();
+  void set_allocated_binary(::substrait::Type_Binary* binary);
+  private:
+  const ::substrait::Type_Binary& _internal_binary() const;
+  ::substrait::Type_Binary* _internal_mutable_binary();
+  public:
+  void unsafe_arena_set_allocated_binary(
+      ::substrait::Type_Binary* binary);
+  ::substrait::Type_Binary* unsafe_arena_release_binary();
+
+  // .substrait.Type.Timestamp timestamp = 14;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  const ::substrait::Type_Timestamp& timestamp() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Timestamp* release_timestamp();
+  ::substrait::Type_Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp);
+  private:
+  const ::substrait::Type_Timestamp& _internal_timestamp() const;
+  ::substrait::Type_Timestamp* _internal_mutable_timestamp();
+  public:
+  void unsafe_arena_set_allocated_timestamp(
+      ::substrait::Type_Timestamp* timestamp);
+  ::substrait::Type_Timestamp* unsafe_arena_release_timestamp();
+
+  // .substrait.Type.Date date = 16;
+  bool has_date() const;
+  private:
+  bool _internal_has_date() const;
+  public:
+  void clear_date();
+  const ::substrait::Type_Date& date() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Date* release_date();
+  ::substrait::Type_Date* mutable_date();
+  void set_allocated_date(::substrait::Type_Date* date);
+  private:
+  const ::substrait::Type_Date& _internal_date() const;
+  ::substrait::Type_Date* _internal_mutable_date();
+  public:
+  void unsafe_arena_set_allocated_date(
+      ::substrait::Type_Date* date);
+  ::substrait::Type_Date* unsafe_arena_release_date();
+
+  // .substrait.Type.Time time = 17;
+  bool has_time() const;
+  private:
+  bool _internal_has_time() const;
+  public:
+  void clear_time();
+  const ::substrait::Type_Time& time() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Time* release_time();
+  ::substrait::Type_Time* mutable_time();
+  void set_allocated_time(::substrait::Type_Time* time);
+  private:
+  const ::substrait::Type_Time& _internal_time() const;
+  ::substrait::Type_Time* _internal_mutable_time();
+  public:
+  void unsafe_arena_set_allocated_time(
+      ::substrait::Type_Time* time);
+  ::substrait::Type_Time* unsafe_arena_release_time();
+
+  // .substrait.Type.IntervalYear interval_year = 19;
+  bool has_interval_year() const;
+  private:
+  bool _internal_has_interval_year() const;
+  public:
+  void clear_interval_year();
+  const ::substrait::Type_IntervalYear& interval_year() const;
+  PROTOBUF_NODISCARD ::substrait::Type_IntervalYear* release_interval_year();
+  ::substrait::Type_IntervalYear* mutable_interval_year();
+  void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year);
+  private:
+  const ::substrait::Type_IntervalYear& _internal_interval_year() const;
+  ::substrait::Type_IntervalYear* _internal_mutable_interval_year();
+  public:
+  void unsafe_arena_set_allocated_interval_year(
+      ::substrait::Type_IntervalYear* interval_year);
+  ::substrait::Type_IntervalYear* unsafe_arena_release_interval_year();
+
+  // .substrait.Type.IntervalDay interval_day = 20;
+  bool has_interval_day() const;
+  private:
+  bool _internal_has_interval_day() const;
+  public:
+  void clear_interval_day();
+  const ::substrait::Type_IntervalDay& interval_day() const;
+  PROTOBUF_NODISCARD ::substrait::Type_IntervalDay* release_interval_day();
+  ::substrait::Type_IntervalDay* mutable_interval_day();
+  void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day);
+  private:
+  const ::substrait::Type_IntervalDay& _internal_interval_day() const;
+  ::substrait::Type_IntervalDay* _internal_mutable_interval_day();
+  public:
+  void unsafe_arena_set_allocated_interval_day(
+      ::substrait::Type_IntervalDay* interval_day);
+  ::substrait::Type_IntervalDay* unsafe_arena_release_interval_day();
+
+  // .substrait.Type.TimestampTZ timestamp_tz = 29;
+  bool has_timestamp_tz() const;
+  private:
+  bool _internal_has_timestamp_tz() const;
+  public:
+  void clear_timestamp_tz();
+  const ::substrait::Type_TimestampTZ& timestamp_tz() const;
+  PROTOBUF_NODISCARD ::substrait::Type_TimestampTZ* release_timestamp_tz();
+  ::substrait::Type_TimestampTZ* mutable_timestamp_tz();
+  void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz);
+  private:
+  const ::substrait::Type_TimestampTZ& _internal_timestamp_tz() const;
+  ::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz();
+  public:
+  void unsafe_arena_set_allocated_timestamp_tz(
+      ::substrait::Type_TimestampTZ* timestamp_tz);
+  ::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz();
+
+  // .substrait.Type.UUID uuid = 32;
+  bool has_uuid() const;
+  private:
+  bool _internal_has_uuid() const;
+  public:
+  void clear_uuid();
+  const ::substrait::Type_UUID& uuid() const;
+  PROTOBUF_NODISCARD ::substrait::Type_UUID* release_uuid();
+  ::substrait::Type_UUID* mutable_uuid();
+  void set_allocated_uuid(::substrait::Type_UUID* uuid);
+  private:
+  const ::substrait::Type_UUID& _internal_uuid() const;
+  ::substrait::Type_UUID* _internal_mutable_uuid();
+  public:
+  void unsafe_arena_set_allocated_uuid(
+      ::substrait::Type_UUID* uuid);
+  ::substrait::Type_UUID* unsafe_arena_release_uuid();
+
+  // .substrait.Type.FixedChar fixed_char = 21;
+  bool has_fixed_char() const;
+  private:
+  bool _internal_has_fixed_char() const;
+  public:
+  void clear_fixed_char();
+  const ::substrait::Type_FixedChar& fixed_char() const;
+  PROTOBUF_NODISCARD ::substrait::Type_FixedChar* release_fixed_char();
+  ::substrait::Type_FixedChar* mutable_fixed_char();
+  void set_allocated_fixed_char(::substrait::Type_FixedChar* fixed_char);
+  private:
+  const ::substrait::Type_FixedChar& _internal_fixed_char() const;
+  ::substrait::Type_FixedChar* _internal_mutable_fixed_char();
+  public:
+  void unsafe_arena_set_allocated_fixed_char(
+      ::substrait::Type_FixedChar* fixed_char);
+  ::substrait::Type_FixedChar* unsafe_arena_release_fixed_char();
+
+  // .substrait.Type.VarChar varchar = 22;
+  bool has_varchar() const;
+  private:
+  bool _internal_has_varchar() const;
+  public:
+  void clear_varchar();
+  const ::substrait::Type_VarChar& varchar() const;
+  PROTOBUF_NODISCARD ::substrait::Type_VarChar* release_varchar();
+  ::substrait::Type_VarChar* mutable_varchar();
+  void set_allocated_varchar(::substrait::Type_VarChar* varchar);
+  private:
+  const ::substrait::Type_VarChar& _internal_varchar() const;
+  ::substrait::Type_VarChar* _internal_mutable_varchar();
+  public:
+  void unsafe_arena_set_allocated_varchar(
+      ::substrait::Type_VarChar* varchar);
+  ::substrait::Type_VarChar* unsafe_arena_release_varchar();
+
+  // .substrait.Type.FixedBinary fixed_binary = 23;
+  bool has_fixed_binary() const;
+  private:
+  bool _internal_has_fixed_binary() const;
+  public:
+  void clear_fixed_binary();
+  const ::substrait::Type_FixedBinary& fixed_binary() const;
+  PROTOBUF_NODISCARD ::substrait::Type_FixedBinary* release_fixed_binary();
+  ::substrait::Type_FixedBinary* mutable_fixed_binary();
+  void set_allocated_fixed_binary(::substrait::Type_FixedBinary* fixed_binary);
+  private:
+  const ::substrait::Type_FixedBinary& _internal_fixed_binary() const;
+  ::substrait::Type_FixedBinary* _internal_mutable_fixed_binary();
+  public:
+  void unsafe_arena_set_allocated_fixed_binary(
+      ::substrait::Type_FixedBinary* fixed_binary);
+  ::substrait::Type_FixedBinary* unsafe_arena_release_fixed_binary();
+
+  // .substrait.Type.Decimal decimal = 24;
+  bool has_decimal() const;
+  private:
+  bool _internal_has_decimal() const;
+  public:
+  void clear_decimal();
+  const ::substrait::Type_Decimal& decimal() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Decimal* release_decimal();
+  ::substrait::Type_Decimal* mutable_decimal();
+  void set_allocated_decimal(::substrait::Type_Decimal* decimal);
+  private:
+  const ::substrait::Type_Decimal& _internal_decimal() const;
+  ::substrait::Type_Decimal* _internal_mutable_decimal();
+  public:
+  void unsafe_arena_set_allocated_decimal(
+      ::substrait::Type_Decimal* decimal);
+  ::substrait::Type_Decimal* unsafe_arena_release_decimal();
+
+  // .substrait.Type.Struct struct = 25;
+  bool has_struct_() const;
+  private:
+  bool _internal_has_struct_() const;
+  public:
+  void clear_struct_();
+  const ::substrait::Type_Struct& struct_() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Struct* release_struct_();
+  ::substrait::Type_Struct* mutable_struct_();
+  void set_allocated_struct_(::substrait::Type_Struct* struct_);
+  private:
+  const ::substrait::Type_Struct& _internal_struct_() const;
+  ::substrait::Type_Struct* _internal_mutable_struct_();
+  public:
+  void unsafe_arena_set_allocated_struct_(
+      ::substrait::Type_Struct* struct_);
+  ::substrait::Type_Struct* unsafe_arena_release_struct_();
+
+  // .substrait.Type.List list = 27;
+  bool has_list() const;
+  private:
+  bool _internal_has_list() const;
+  public:
+  void clear_list();
+  const ::substrait::Type_List& list() const;
+  PROTOBUF_NODISCARD ::substrait::Type_List* release_list();
+  ::substrait::Type_List* mutable_list();
+  void set_allocated_list(::substrait::Type_List* list);
+  private:
+  const ::substrait::Type_List& _internal_list() const;
+  ::substrait::Type_List* _internal_mutable_list();
+  public:
+  void unsafe_arena_set_allocated_list(
+      ::substrait::Type_List* list);
+  ::substrait::Type_List* unsafe_arena_release_list();
+
+  // .substrait.Type.Map map = 28;
+  bool has_map() const;
+  private:
+  bool _internal_has_map() const;
+  public:
+  void clear_map();
+  const ::substrait::Type_Map& map() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Map* release_map();
+  ::substrait::Type_Map* mutable_map();
+  void set_allocated_map(::substrait::Type_Map* map);
+  private:
+  const ::substrait::Type_Map& _internal_map() const;
+  ::substrait::Type_Map* _internal_mutable_map();
+  public:
+  void unsafe_arena_set_allocated_map(
+      ::substrait::Type_Map* map);
+  ::substrait::Type_Map* unsafe_arena_release_map();
+
+  // uint32 user_defined_type_reference = 31;
+  bool has_user_defined_type_reference() const;
+  private:
+  bool _internal_has_user_defined_type_reference() const;
+  public:
+  void clear_user_defined_type_reference();
+  uint32_t user_defined_type_reference() const;
+  void set_user_defined_type_reference(uint32_t value);
+  private:
+  uint32_t _internal_user_defined_type_reference() const;
+  void _internal_set_user_defined_type_reference(uint32_t value);
+  public:
+
+  void clear_kind();
+  KindCase kind_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.Type)
+ private:
+  class _Internal;
+  void set_has_bool_();
+  void set_has_i8();
+  void set_has_i16();
+  void set_has_i32();
+  void set_has_i64();
+  void set_has_fp32();
+  void set_has_fp64();
+  void set_has_string();
+  void set_has_binary();
+  void set_has_timestamp();
+  void set_has_date();
+  void set_has_time();
+  void set_has_interval_year();
+  void set_has_interval_day();
+  void set_has_timestamp_tz();
+  void set_has_uuid();
+  void set_has_fixed_char();
+  void set_has_varchar();
+  void set_has_fixed_binary();
+  void set_has_decimal();
+  void set_has_struct_();
+  void set_has_list();
+  void set_has_map();
+  void set_has_user_defined_type_reference();
+
+  inline bool has_kind() const;
+  inline void clear_has_kind();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union KindUnion {
+    constexpr KindUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Type_Boolean* bool__;
+    ::substrait::Type_I8* i8_;
+    ::substrait::Type_I16* i16_;
+    ::substrait::Type_I32* i32_;
+    ::substrait::Type_I64* i64_;
+    ::substrait::Type_FP32* fp32_;
+    ::substrait::Type_FP64* fp64_;
+    ::substrait::Type_String* string_;
+    ::substrait::Type_Binary* binary_;
+    ::substrait::Type_Timestamp* timestamp_;
+    ::substrait::Type_Date* date_;
+    ::substrait::Type_Time* time_;
+    ::substrait::Type_IntervalYear* interval_year_;
+    ::substrait::Type_IntervalDay* interval_day_;
+    ::substrait::Type_TimestampTZ* timestamp_tz_;
+    ::substrait::Type_UUID* uuid_;
+    ::substrait::Type_FixedChar* fixed_char_;
+    ::substrait::Type_VarChar* varchar_;
+    ::substrait::Type_FixedBinary* fixed_binary_;
+    ::substrait::Type_Decimal* decimal_;
+    ::substrait::Type_Struct* struct__;
+    ::substrait::Type_List* list_;
+    ::substrait::Type_Map* map_;
+    uint32_t user_defined_type_reference_;
+  } kind_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// -------------------------------------------------------------------
+
+class NamedStruct final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.NamedStruct) */ {
+ public:
+  inline NamedStruct() : NamedStruct(nullptr) {}
+  ~NamedStruct() override;
+  explicit constexpr NamedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  NamedStruct(const NamedStruct& from);
+  NamedStruct(NamedStruct&& from) noexcept
+    : NamedStruct() {
+    *this = ::std::move(from);
+  }
+
+  inline NamedStruct& operator=(const NamedStruct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline NamedStruct& operator=(NamedStruct&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const NamedStruct& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const NamedStruct* internal_default_instance() {
+    return reinterpret_cast<const NamedStruct*>(
+               &_NamedStruct_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    24;
+
+  friend void swap(NamedStruct& a, NamedStruct& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(NamedStruct* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(NamedStruct* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  NamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<NamedStruct>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const NamedStruct& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const NamedStruct& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(NamedStruct* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.NamedStruct";
+  }
+  protected:
+  explicit NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNamesFieldNumber = 1,
+    kStructFieldNumber = 2,
+  };
+  // repeated string names = 1;
+  int names_size() const;
+  private:
+  int _internal_names_size() const;
+  public:
+  void clear_names();
+  const std::string& names(int index) const;
+  std::string* mutable_names(int index);
+  void set_names(int index, const std::string& value);
+  void set_names(int index, std::string&& value);
+  void set_names(int index, const char* value);
+  void set_names(int index, const char* value, size_t size);
+  std::string* add_names();
+  void add_names(const std::string& value);
+  void add_names(std::string&& value);
+  void add_names(const char* value);
+  void add_names(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& names() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_names();
+  private:
+  const std::string& _internal_names(int index) const;
+  std::string* _internal_add_names();
+  public:
+
+  // .substrait.Type.Struct struct = 2;
+  bool has_struct_() const;
+  private:
+  bool _internal_has_struct_() const;
+  public:
+  void clear_struct_();
+  const ::substrait::Type_Struct& struct_() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Struct* release_struct_();
+  ::substrait::Type_Struct* mutable_struct_();
+  void set_allocated_struct_(::substrait::Type_Struct* struct_);
+  private:
+  const ::substrait::Type_Struct& _internal_struct_() const;
+  ::substrait::Type_Struct* _internal_mutable_struct_();
+  public:
+  void unsafe_arena_set_allocated_struct_(
+      ::substrait::Type_Struct* struct_);
+  ::substrait::Type_Struct* unsafe_arena_release_struct_();
+
+  // @@protoc_insertion_point(class_scope:substrait.NamedStruct)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> names_;
+  ::substrait::Type_Struct* struct__;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Type_Boolean
+
+// uint32 type_variation_reference = 1;
+inline void Type_Boolean::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_Boolean::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_Boolean::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Boolean.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_Boolean::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_Boolean::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Boolean.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_Boolean::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_Boolean::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_Boolean::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Boolean.nullability)
+  return _internal_nullability();
+}
+inline void Type_Boolean::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_Boolean::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Boolean.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_I8
+
+// uint32 type_variation_reference = 1;
+inline void Type_I8::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_I8::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_I8::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.I8.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_I8::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_I8::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.I8.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_I8::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_I8::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_I8::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.I8.nullability)
+  return _internal_nullability();
+}
+inline void Type_I8::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_I8::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.I8.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_I16
+
+// uint32 type_variation_reference = 1;
+inline void Type_I16::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_I16::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_I16::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.I16.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_I16::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_I16::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.I16.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_I16::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_I16::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_I16::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.I16.nullability)
+  return _internal_nullability();
+}
+inline void Type_I16::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_I16::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.I16.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_I32
+
+// uint32 type_variation_reference = 1;
+inline void Type_I32::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_I32::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_I32::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.I32.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_I32::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_I32::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.I32.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_I32::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_I32::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_I32::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.I32.nullability)
+  return _internal_nullability();
+}
+inline void Type_I32::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_I32::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.I32.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_I64
+
+// uint32 type_variation_reference = 1;
+inline void Type_I64::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_I64::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_I64::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.I64.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_I64::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_I64::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.I64.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_I64::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_I64::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_I64::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.I64.nullability)
+  return _internal_nullability();
+}
+inline void Type_I64::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_I64::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.I64.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_FP32
+
+// uint32 type_variation_reference = 1;
+inline void Type_FP32::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_FP32::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_FP32::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.FP32.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_FP32::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_FP32::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.FP32.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_FP32::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_FP32::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_FP32::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.FP32.nullability)
+  return _internal_nullability();
+}
+inline void Type_FP32::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_FP32::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.FP32.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_FP64
+
+// uint32 type_variation_reference = 1;
+inline void Type_FP64::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_FP64::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_FP64::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.FP64.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_FP64::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_FP64::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.FP64.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_FP64::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_FP64::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_FP64::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.FP64.nullability)
+  return _internal_nullability();
+}
+inline void Type_FP64::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_FP64::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.FP64.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_String
+
+// uint32 type_variation_reference = 1;
+inline void Type_String::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_String::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_String::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.String.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_String::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_String::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.String.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_String::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_String::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_String::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.String.nullability)
+  return _internal_nullability();
+}
+inline void Type_String::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_String::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.String.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_Binary
+
+// uint32 type_variation_reference = 1;
+inline void Type_Binary::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_Binary::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_Binary::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Binary.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_Binary::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_Binary::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Binary.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_Binary::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_Binary::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_Binary::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Binary.nullability)
+  return _internal_nullability();
+}
+inline void Type_Binary::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_Binary::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Binary.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_Timestamp
+
+// uint32 type_variation_reference = 1;
+inline void Type_Timestamp::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_Timestamp::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_Timestamp::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Timestamp.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_Timestamp::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_Timestamp::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Timestamp.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_Timestamp::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_Timestamp::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_Timestamp::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Timestamp.nullability)
+  return _internal_nullability();
+}
+inline void Type_Timestamp::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_Timestamp::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Timestamp.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_Date
+
+// uint32 type_variation_reference = 1;
+inline void Type_Date::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_Date::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_Date::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Date.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_Date::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_Date::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Date.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_Date::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_Date::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_Date::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Date.nullability)
+  return _internal_nullability();
+}
+inline void Type_Date::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_Date::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Date.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_Time
+
+// uint32 type_variation_reference = 1;
+inline void Type_Time::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_Time::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_Time::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Time.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_Time::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_Time::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Time.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_Time::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_Time::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_Time::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Time.nullability)
+  return _internal_nullability();
+}
+inline void Type_Time::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_Time::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Time.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_TimestampTZ
+
+// uint32 type_variation_reference = 1;
+inline void Type_TimestampTZ::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_TimestampTZ::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_TimestampTZ::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.TimestampTZ.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_TimestampTZ::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_TimestampTZ::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.TimestampTZ.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_TimestampTZ::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_TimestampTZ::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_TimestampTZ::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.TimestampTZ.nullability)
+  return _internal_nullability();
+}
+inline void Type_TimestampTZ::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_TimestampTZ::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.TimestampTZ.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_IntervalYear
+
+// uint32 type_variation_reference = 1;
+inline void Type_IntervalYear::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_IntervalYear::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_IntervalYear::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.IntervalYear.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_IntervalYear::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_IntervalYear::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.IntervalYear.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_IntervalYear::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_IntervalYear::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_IntervalYear::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.IntervalYear.nullability)
+  return _internal_nullability();
+}
+inline void Type_IntervalYear::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_IntervalYear::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.IntervalYear.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_IntervalDay
+
+// uint32 type_variation_reference = 1;
+inline void Type_IntervalDay::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_IntervalDay::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_IntervalDay::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.IntervalDay.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_IntervalDay::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_IntervalDay::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.IntervalDay.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_IntervalDay::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_IntervalDay::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_IntervalDay::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.IntervalDay.nullability)
+  return _internal_nullability();
+}
+inline void Type_IntervalDay::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_IntervalDay::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.IntervalDay.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_UUID
+
+// uint32 type_variation_reference = 1;
+inline void Type_UUID::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_UUID::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_UUID::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.UUID.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_UUID::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_UUID::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.UUID.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 2;
+inline void Type_UUID::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_UUID::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_UUID::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.UUID.nullability)
+  return _internal_nullability();
+}
+inline void Type_UUID::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_UUID::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.UUID.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_FixedChar
+
+// int32 length = 1;
+inline void Type_FixedChar::clear_length() {
+  length_ = 0;
+}
+inline int32_t Type_FixedChar::_internal_length() const {
+  return length_;
+}
+inline int32_t Type_FixedChar::length() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.FixedChar.length)
+  return _internal_length();
+}
+inline void Type_FixedChar::_internal_set_length(int32_t value) {
+  
+  length_ = value;
+}
+inline void Type_FixedChar::set_length(int32_t value) {
+  _internal_set_length(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.FixedChar.length)
+}
+
+// uint32 type_variation_reference = 2;
+inline void Type_FixedChar::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_FixedChar::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_FixedChar::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.FixedChar.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_FixedChar::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_FixedChar::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.FixedChar.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void Type_FixedChar::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_FixedChar::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_FixedChar::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.FixedChar.nullability)
+  return _internal_nullability();
+}
+inline void Type_FixedChar::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_FixedChar::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.FixedChar.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_VarChar
+
+// int32 length = 1;
+inline void Type_VarChar::clear_length() {
+  length_ = 0;
+}
+inline int32_t Type_VarChar::_internal_length() const {
+  return length_;
+}
+inline int32_t Type_VarChar::length() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.VarChar.length)
+  return _internal_length();
+}
+inline void Type_VarChar::_internal_set_length(int32_t value) {
+  
+  length_ = value;
+}
+inline void Type_VarChar::set_length(int32_t value) {
+  _internal_set_length(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.VarChar.length)
+}
+
+// uint32 type_variation_reference = 2;
+inline void Type_VarChar::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_VarChar::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_VarChar::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.VarChar.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_VarChar::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_VarChar::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.VarChar.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void Type_VarChar::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_VarChar::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_VarChar::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.VarChar.nullability)
+  return _internal_nullability();
+}
+inline void Type_VarChar::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_VarChar::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.VarChar.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_FixedBinary
+
+// int32 length = 1;
+inline void Type_FixedBinary::clear_length() {
+  length_ = 0;
+}
+inline int32_t Type_FixedBinary::_internal_length() const {
+  return length_;
+}
+inline int32_t Type_FixedBinary::length() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.FixedBinary.length)
+  return _internal_length();
+}
+inline void Type_FixedBinary::_internal_set_length(int32_t value) {
+  
+  length_ = value;
+}
+inline void Type_FixedBinary::set_length(int32_t value) {
+  _internal_set_length(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.FixedBinary.length)
+}
+
+// uint32 type_variation_reference = 2;
+inline void Type_FixedBinary::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_FixedBinary::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_FixedBinary::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.FixedBinary.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_FixedBinary::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_FixedBinary::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.FixedBinary.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void Type_FixedBinary::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_FixedBinary::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_FixedBinary::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.FixedBinary.nullability)
+  return _internal_nullability();
+}
+inline void Type_FixedBinary::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_FixedBinary::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.FixedBinary.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_Decimal
+
+// int32 scale = 1;
+inline void Type_Decimal::clear_scale() {
+  scale_ = 0;
+}
+inline int32_t Type_Decimal::_internal_scale() const {
+  return scale_;
+}
+inline int32_t Type_Decimal::scale() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Decimal.scale)
+  return _internal_scale();
+}
+inline void Type_Decimal::_internal_set_scale(int32_t value) {
+  
+  scale_ = value;
+}
+inline void Type_Decimal::set_scale(int32_t value) {
+  _internal_set_scale(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Decimal.scale)
+}
+
+// int32 precision = 2;
+inline void Type_Decimal::clear_precision() {
+  precision_ = 0;
+}
+inline int32_t Type_Decimal::_internal_precision() const {
+  return precision_;
+}
+inline int32_t Type_Decimal::precision() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Decimal.precision)
+  return _internal_precision();
+}
+inline void Type_Decimal::_internal_set_precision(int32_t value) {
+  
+  precision_ = value;
+}
+inline void Type_Decimal::set_precision(int32_t value) {
+  _internal_set_precision(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Decimal.precision)
+}
+
+// uint32 type_variation_reference = 3;
+inline void Type_Decimal::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_Decimal::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_Decimal::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Decimal.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_Decimal::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_Decimal::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Decimal.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 4;
+inline void Type_Decimal::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_Decimal::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_Decimal::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Decimal.nullability)
+  return _internal_nullability();
+}
+inline void Type_Decimal::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_Decimal::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Decimal.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_Struct
+
+// repeated .substrait.Type types = 1;
+inline int Type_Struct::_internal_types_size() const {
+  return types_.size();
+}
+inline int Type_Struct::types_size() const {
+  return _internal_types_size();
+}
+inline void Type_Struct::clear_types() {
+  types_.Clear();
+}
+inline ::substrait::Type* Type_Struct::mutable_types(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.Type.Struct.types)
+  return types_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >*
+Type_Struct::mutable_types() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.Type.Struct.types)
+  return &types_;
+}
+inline const ::substrait::Type& Type_Struct::_internal_types(int index) const {
+  return types_.Get(index);
+}
+inline const ::substrait::Type& Type_Struct::types(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Struct.types)
+  return _internal_types(index);
+}
+inline ::substrait::Type* Type_Struct::_internal_add_types() {
+  return types_.Add();
+}
+inline ::substrait::Type* Type_Struct::add_types() {
+  ::substrait::Type* _add = _internal_add_types();
+  // @@protoc_insertion_point(field_add:substrait.Type.Struct.types)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >&
+Type_Struct::types() const {
+  // @@protoc_insertion_point(field_list:substrait.Type.Struct.types)
+  return types_;
+}
+
+// uint32 type_variation_reference = 2;
+inline void Type_Struct::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_Struct::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_Struct::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Struct.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_Struct::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_Struct::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Struct.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void Type_Struct::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_Struct::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_Struct::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Struct.nullability)
+  return _internal_nullability();
+}
+inline void Type_Struct::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_Struct::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Struct.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_List
+
+// .substrait.Type type = 1;
+inline bool Type_List::_internal_has_type() const {
+  return this != internal_default_instance() && type_ != nullptr;
+}
+inline bool Type_List::has_type() const {
+  return _internal_has_type();
+}
+inline void Type_List::clear_type() {
+  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
+    delete type_;
+  }
+  type_ = nullptr;
+}
+inline const ::substrait::Type& Type_List::_internal_type() const {
+  const ::substrait::Type* p = type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Type&>(
+      ::substrait::_Type_default_instance_);
+}
+inline const ::substrait::Type& Type_List::type() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.List.type)
+  return _internal_type();
+}
+inline void Type_List::unsafe_arena_set_allocated_type(
+    ::substrait::Type* type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
+  }
+  type_ = type;
+  if (type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.List.type)
+}
+inline ::substrait::Type* Type_List::release_type() {
+  
+  ::substrait::Type* temp = type_;
+  type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Type* Type_List::unsafe_arena_release_type() {
+  // @@protoc_insertion_point(field_release:substrait.Type.List.type)
+  
+  ::substrait::Type* temp = type_;
+  type_ = nullptr;
+  return temp;
+}
+inline ::substrait::Type* Type_List::_internal_mutable_type() {
+  
+  if (type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation());
+    type_ = p;
+  }
+  return type_;
+}
+inline ::substrait::Type* Type_List::mutable_type() {
+  ::substrait::Type* _msg = _internal_mutable_type();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.List.type)
+  return _msg;
+}
+inline void Type_List::set_allocated_type(::substrait::Type* type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete type_;
+  }
+  if (type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type>::GetOwningArena(type);
+    if (message_arena != submessage_arena) {
+      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  type_ = type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.List.type)
+}
+
+// uint32 type_variation_reference = 2;
+inline void Type_List::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_List::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_List::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.List.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_List::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_List::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.List.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void Type_List::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_List::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_List::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.List.nullability)
+  return _internal_nullability();
+}
+inline void Type_List::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_List::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.List.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type_Map
+
+// .substrait.Type key = 1;
+inline bool Type_Map::_internal_has_key() const {
+  return this != internal_default_instance() && key_ != nullptr;
+}
+inline bool Type_Map::has_key() const {
+  return _internal_has_key();
+}
+inline void Type_Map::clear_key() {
+  if (GetArenaForAllocation() == nullptr && key_ != nullptr) {
+    delete key_;
+  }
+  key_ = nullptr;
+}
+inline const ::substrait::Type& Type_Map::_internal_key() const {
+  const ::substrait::Type* p = key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Type&>(
+      ::substrait::_Type_default_instance_);
+}
+inline const ::substrait::Type& Type_Map::key() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Map.key)
+  return _internal_key();
+}
+inline void Type_Map::unsafe_arena_set_allocated_key(
+    ::substrait::Type* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_);
+  }
+  key_ = key;
+  if (key) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.Map.key)
+}
+inline ::substrait::Type* Type_Map::release_key() {
+  
+  ::substrait::Type* temp = key_;
+  key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Type* Type_Map::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:substrait.Type.Map.key)
+  
+  ::substrait::Type* temp = key_;
+  key_ = nullptr;
+  return temp;
+}
+inline ::substrait::Type* Type_Map::_internal_mutable_key() {
+  
+  if (key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation());
+    key_ = p;
+  }
+  return key_;
+}
+inline ::substrait::Type* Type_Map::mutable_key() {
+  ::substrait::Type* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.Map.key)
+  return _msg;
+}
+inline void Type_Map::set_allocated_key(::substrait::Type* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type>::GetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.Map.key)
+}
+
+// .substrait.Type value = 2;
+inline bool Type_Map::_internal_has_value() const {
+  return this != internal_default_instance() && value_ != nullptr;
+}
+inline bool Type_Map::has_value() const {
+  return _internal_has_value();
+}
+inline void Type_Map::clear_value() {
+  if (GetArenaForAllocation() == nullptr && value_ != nullptr) {
+    delete value_;
+  }
+  value_ = nullptr;
+}
+inline const ::substrait::Type& Type_Map::_internal_value() const {
+  const ::substrait::Type* p = value_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Type&>(
+      ::substrait::_Type_default_instance_);
+}
+inline const ::substrait::Type& Type_Map::value() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Map.value)
+  return _internal_value();
+}
+inline void Type_Map::unsafe_arena_set_allocated_value(
+    ::substrait::Type* value) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
+  }
+  value_ = value;
+  if (value) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.Map.value)
+}
+inline ::substrait::Type* Type_Map::release_value() {
+  
+  ::substrait::Type* temp = value_;
+  value_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Type* Type_Map::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_release:substrait.Type.Map.value)
+  
+  ::substrait::Type* temp = value_;
+  value_ = nullptr;
+  return temp;
+}
+inline ::substrait::Type* Type_Map::_internal_mutable_value() {
+  
+  if (value_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation());
+    value_ = p;
+  }
+  return value_;
+}
+inline ::substrait::Type* Type_Map::mutable_value() {
+  ::substrait::Type* _msg = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.Map.value)
+  return _msg;
+}
+inline void Type_Map::set_allocated_value(::substrait::Type* value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete value_;
+  }
+  if (value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type>::GetOwningArena(value);
+    if (message_arena != submessage_arena) {
+      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  value_ = value;
+  // @@protoc_insertion_point(field_set_allocated:substrait.Type.Map.value)
+}
+
+// uint32 type_variation_reference = 3;
+inline void Type_Map::clear_type_variation_reference() {
+  type_variation_reference_ = 0u;
+}
+inline uint32_t Type_Map::_internal_type_variation_reference() const {
+  return type_variation_reference_;
+}
+inline uint32_t Type_Map::type_variation_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Map.type_variation_reference)
+  return _internal_type_variation_reference();
+}
+inline void Type_Map::_internal_set_type_variation_reference(uint32_t value) {
+  
+  type_variation_reference_ = value;
+}
+inline void Type_Map::set_type_variation_reference(uint32_t value) {
+  _internal_set_type_variation_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Map.type_variation_reference)
+}
+
+// .substrait.Type.Nullability nullability = 4;
+inline void Type_Map::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability Type_Map::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability Type_Map::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.Map.nullability)
+  return _internal_nullability();
+}
+inline void Type_Map::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void Type_Map::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.Map.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// Type
+
+// .substrait.Type.Boolean bool = 1;
+inline bool Type::_internal_has_bool_() const {
+  return kind_case() == kBool;
+}
+inline bool Type::has_bool_() const {
+  return _internal_has_bool_();
+}
+inline void Type::set_has_bool_() {
+  _oneof_case_[0] = kBool;
+}
+inline void Type::clear_bool_() {
+  if (_internal_has_bool_()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.bool__;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_Boolean* Type::release_bool_() {
+  // @@protoc_insertion_point(field_release:substrait.Type.bool)
+  if (_internal_has_bool_()) {
+    clear_has_kind();
+      ::substrait::Type_Boolean* temp = kind_.bool__;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.bool__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Boolean& Type::_internal_bool_() const {
+  return _internal_has_bool_()
+      ? *kind_.bool__
+      : reinterpret_cast< ::substrait::Type_Boolean&>(::substrait::_Type_Boolean_default_instance_);
+}
+inline const ::substrait::Type_Boolean& Type::bool_() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.bool)
+  return _internal_bool_();
+}
+inline ::substrait::Type_Boolean* Type::unsafe_arena_release_bool_() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.bool)
+  if (_internal_has_bool_()) {
+    clear_has_kind();
+    ::substrait::Type_Boolean* temp = kind_.bool__;
+    kind_.bool__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_bool_(::substrait::Type_Boolean* bool_) {
+  clear_kind();
+  if (bool_) {
+    set_has_bool_();
+    kind_.bool__ = bool_;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.bool)
+}
+inline ::substrait::Type_Boolean* Type::_internal_mutable_bool_() {
+  if (!_internal_has_bool_()) {
+    clear_kind();
+    set_has_bool_();
+    kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArenaForAllocation());
+  }
+  return kind_.bool__;
+}
+inline ::substrait::Type_Boolean* Type::mutable_bool_() {
+  ::substrait::Type_Boolean* _msg = _internal_mutable_bool_();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.bool)
+  return _msg;
+}
+
+// .substrait.Type.I8 i8 = 2;
+inline bool Type::_internal_has_i8() const {
+  return kind_case() == kI8;
+}
+inline bool Type::has_i8() const {
+  return _internal_has_i8();
+}
+inline void Type::set_has_i8() {
+  _oneof_case_[0] = kI8;
+}
+inline void Type::clear_i8() {
+  if (_internal_has_i8()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.i8_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_I8* Type::release_i8() {
+  // @@protoc_insertion_point(field_release:substrait.Type.i8)
+  if (_internal_has_i8()) {
+    clear_has_kind();
+      ::substrait::Type_I8* temp = kind_.i8_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.i8_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_I8& Type::_internal_i8() const {
+  return _internal_has_i8()
+      ? *kind_.i8_
+      : reinterpret_cast< ::substrait::Type_I8&>(::substrait::_Type_I8_default_instance_);
+}
+inline const ::substrait::Type_I8& Type::i8() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.i8)
+  return _internal_i8();
+}
+inline ::substrait::Type_I8* Type::unsafe_arena_release_i8() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.i8)
+  if (_internal_has_i8()) {
+    clear_has_kind();
+    ::substrait::Type_I8* temp = kind_.i8_;
+    kind_.i8_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_i8(::substrait::Type_I8* i8) {
+  clear_kind();
+  if (i8) {
+    set_has_i8();
+    kind_.i8_ = i8;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.i8)
+}
+inline ::substrait::Type_I8* Type::_internal_mutable_i8() {
+  if (!_internal_has_i8()) {
+    clear_kind();
+    set_has_i8();
+    kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArenaForAllocation());
+  }
+  return kind_.i8_;
+}
+inline ::substrait::Type_I8* Type::mutable_i8() {
+  ::substrait::Type_I8* _msg = _internal_mutable_i8();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.i8)
+  return _msg;
+}
+
+// .substrait.Type.I16 i16 = 3;
+inline bool Type::_internal_has_i16() const {
+  return kind_case() == kI16;
+}
+inline bool Type::has_i16() const {
+  return _internal_has_i16();
+}
+inline void Type::set_has_i16() {
+  _oneof_case_[0] = kI16;
+}
+inline void Type::clear_i16() {
+  if (_internal_has_i16()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.i16_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_I16* Type::release_i16() {
+  // @@protoc_insertion_point(field_release:substrait.Type.i16)
+  if (_internal_has_i16()) {
+    clear_has_kind();
+      ::substrait::Type_I16* temp = kind_.i16_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.i16_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_I16& Type::_internal_i16() const {
+  return _internal_has_i16()
+      ? *kind_.i16_
+      : reinterpret_cast< ::substrait::Type_I16&>(::substrait::_Type_I16_default_instance_);
+}
+inline const ::substrait::Type_I16& Type::i16() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.i16)
+  return _internal_i16();
+}
+inline ::substrait::Type_I16* Type::unsafe_arena_release_i16() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.i16)
+  if (_internal_has_i16()) {
+    clear_has_kind();
+    ::substrait::Type_I16* temp = kind_.i16_;
+    kind_.i16_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_i16(::substrait::Type_I16* i16) {
+  clear_kind();
+  if (i16) {
+    set_has_i16();
+    kind_.i16_ = i16;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.i16)
+}
+inline ::substrait::Type_I16* Type::_internal_mutable_i16() {
+  if (!_internal_has_i16()) {
+    clear_kind();
+    set_has_i16();
+    kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArenaForAllocation());
+  }
+  return kind_.i16_;
+}
+inline ::substrait::Type_I16* Type::mutable_i16() {
+  ::substrait::Type_I16* _msg = _internal_mutable_i16();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.i16)
+  return _msg;
+}
+
+// .substrait.Type.I32 i32 = 5;
+inline bool Type::_internal_has_i32() const {
+  return kind_case() == kI32;
+}
+inline bool Type::has_i32() const {
+  return _internal_has_i32();
+}
+inline void Type::set_has_i32() {
+  _oneof_case_[0] = kI32;
+}
+inline void Type::clear_i32() {
+  if (_internal_has_i32()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.i32_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_I32* Type::release_i32() {
+  // @@protoc_insertion_point(field_release:substrait.Type.i32)
+  if (_internal_has_i32()) {
+    clear_has_kind();
+      ::substrait::Type_I32* temp = kind_.i32_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.i32_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_I32& Type::_internal_i32() const {
+  return _internal_has_i32()
+      ? *kind_.i32_
+      : reinterpret_cast< ::substrait::Type_I32&>(::substrait::_Type_I32_default_instance_);
+}
+inline const ::substrait::Type_I32& Type::i32() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.i32)
+  return _internal_i32();
+}
+inline ::substrait::Type_I32* Type::unsafe_arena_release_i32() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.i32)
+  if (_internal_has_i32()) {
+    clear_has_kind();
+    ::substrait::Type_I32* temp = kind_.i32_;
+    kind_.i32_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_i32(::substrait::Type_I32* i32) {
+  clear_kind();
+  if (i32) {
+    set_has_i32();
+    kind_.i32_ = i32;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.i32)
+}
+inline ::substrait::Type_I32* Type::_internal_mutable_i32() {
+  if (!_internal_has_i32()) {
+    clear_kind();
+    set_has_i32();
+    kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArenaForAllocation());
+  }
+  return kind_.i32_;
+}
+inline ::substrait::Type_I32* Type::mutable_i32() {
+  ::substrait::Type_I32* _msg = _internal_mutable_i32();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.i32)
+  return _msg;
+}
+
+// .substrait.Type.I64 i64 = 7;
+inline bool Type::_internal_has_i64() const {
+  return kind_case() == kI64;
+}
+inline bool Type::has_i64() const {
+  return _internal_has_i64();
+}
+inline void Type::set_has_i64() {
+  _oneof_case_[0] = kI64;
+}
+inline void Type::clear_i64() {
+  if (_internal_has_i64()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.i64_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_I64* Type::release_i64() {
+  // @@protoc_insertion_point(field_release:substrait.Type.i64)
+  if (_internal_has_i64()) {
+    clear_has_kind();
+      ::substrait::Type_I64* temp = kind_.i64_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.i64_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_I64& Type::_internal_i64() const {
+  return _internal_has_i64()
+      ? *kind_.i64_
+      : reinterpret_cast< ::substrait::Type_I64&>(::substrait::_Type_I64_default_instance_);
+}
+inline const ::substrait::Type_I64& Type::i64() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.i64)
+  return _internal_i64();
+}
+inline ::substrait::Type_I64* Type::unsafe_arena_release_i64() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.i64)
+  if (_internal_has_i64()) {
+    clear_has_kind();
+    ::substrait::Type_I64* temp = kind_.i64_;
+    kind_.i64_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_i64(::substrait::Type_I64* i64) {
+  clear_kind();
+  if (i64) {
+    set_has_i64();
+    kind_.i64_ = i64;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.i64)
+}
+inline ::substrait::Type_I64* Type::_internal_mutable_i64() {
+  if (!_internal_has_i64()) {
+    clear_kind();
+    set_has_i64();
+    kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArenaForAllocation());
+  }
+  return kind_.i64_;
+}
+inline ::substrait::Type_I64* Type::mutable_i64() {
+  ::substrait::Type_I64* _msg = _internal_mutable_i64();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.i64)
+  return _msg;
+}
+
+// .substrait.Type.FP32 fp32 = 10;
+inline bool Type::_internal_has_fp32() const {
+  return kind_case() == kFp32;
+}
+inline bool Type::has_fp32() const {
+  return _internal_has_fp32();
+}
+inline void Type::set_has_fp32() {
+  _oneof_case_[0] = kFp32;
+}
+inline void Type::clear_fp32() {
+  if (_internal_has_fp32()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.fp32_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_FP32* Type::release_fp32() {
+  // @@protoc_insertion_point(field_release:substrait.Type.fp32)
+  if (_internal_has_fp32()) {
+    clear_has_kind();
+      ::substrait::Type_FP32* temp = kind_.fp32_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.fp32_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_FP32& Type::_internal_fp32() const {
+  return _internal_has_fp32()
+      ? *kind_.fp32_
+      : reinterpret_cast< ::substrait::Type_FP32&>(::substrait::_Type_FP32_default_instance_);
+}
+inline const ::substrait::Type_FP32& Type::fp32() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.fp32)
+  return _internal_fp32();
+}
+inline ::substrait::Type_FP32* Type::unsafe_arena_release_fp32() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.fp32)
+  if (_internal_has_fp32()) {
+    clear_has_kind();
+    ::substrait::Type_FP32* temp = kind_.fp32_;
+    kind_.fp32_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_fp32(::substrait::Type_FP32* fp32) {
+  clear_kind();
+  if (fp32) {
+    set_has_fp32();
+    kind_.fp32_ = fp32;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.fp32)
+}
+inline ::substrait::Type_FP32* Type::_internal_mutable_fp32() {
+  if (!_internal_has_fp32()) {
+    clear_kind();
+    set_has_fp32();
+    kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArenaForAllocation());
+  }
+  return kind_.fp32_;
+}
+inline ::substrait::Type_FP32* Type::mutable_fp32() {
+  ::substrait::Type_FP32* _msg = _internal_mutable_fp32();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.fp32)
+  return _msg;
+}
+
+// .substrait.Type.FP64 fp64 = 11;
+inline bool Type::_internal_has_fp64() const {
+  return kind_case() == kFp64;
+}
+inline bool Type::has_fp64() const {
+  return _internal_has_fp64();
+}
+inline void Type::set_has_fp64() {
+  _oneof_case_[0] = kFp64;
+}
+inline void Type::clear_fp64() {
+  if (_internal_has_fp64()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.fp64_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_FP64* Type::release_fp64() {
+  // @@protoc_insertion_point(field_release:substrait.Type.fp64)
+  if (_internal_has_fp64()) {
+    clear_has_kind();
+      ::substrait::Type_FP64* temp = kind_.fp64_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.fp64_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_FP64& Type::_internal_fp64() const {
+  return _internal_has_fp64()
+      ? *kind_.fp64_
+      : reinterpret_cast< ::substrait::Type_FP64&>(::substrait::_Type_FP64_default_instance_);
+}
+inline const ::substrait::Type_FP64& Type::fp64() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.fp64)
+  return _internal_fp64();
+}
+inline ::substrait::Type_FP64* Type::unsafe_arena_release_fp64() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.fp64)
+  if (_internal_has_fp64()) {
+    clear_has_kind();
+    ::substrait::Type_FP64* temp = kind_.fp64_;
+    kind_.fp64_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_fp64(::substrait::Type_FP64* fp64) {
+  clear_kind();
+  if (fp64) {
+    set_has_fp64();
+    kind_.fp64_ = fp64;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.fp64)
+}
+inline ::substrait::Type_FP64* Type::_internal_mutable_fp64() {
+  if (!_internal_has_fp64()) {
+    clear_kind();
+    set_has_fp64();
+    kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArenaForAllocation());
+  }
+  return kind_.fp64_;
+}
+inline ::substrait::Type_FP64* Type::mutable_fp64() {
+  ::substrait::Type_FP64* _msg = _internal_mutable_fp64();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.fp64)
+  return _msg;
+}
+
+// .substrait.Type.String string = 12;
+inline bool Type::_internal_has_string() const {
+  return kind_case() == kString;
+}
+inline bool Type::has_string() const {
+  return _internal_has_string();
+}
+inline void Type::set_has_string() {
+  _oneof_case_[0] = kString;
+}
+inline void Type::clear_string() {
+  if (_internal_has_string()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.string_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_String* Type::release_string() {
+  // @@protoc_insertion_point(field_release:substrait.Type.string)
+  if (_internal_has_string()) {
+    clear_has_kind();
+      ::substrait::Type_String* temp = kind_.string_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.string_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_String& Type::_internal_string() const {
+  return _internal_has_string()
+      ? *kind_.string_
+      : reinterpret_cast< ::substrait::Type_String&>(::substrait::_Type_String_default_instance_);
+}
+inline const ::substrait::Type_String& Type::string() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.string)
+  return _internal_string();
+}
+inline ::substrait::Type_String* Type::unsafe_arena_release_string() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.string)
+  if (_internal_has_string()) {
+    clear_has_kind();
+    ::substrait::Type_String* temp = kind_.string_;
+    kind_.string_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_string(::substrait::Type_String* string) {
+  clear_kind();
+  if (string) {
+    set_has_string();
+    kind_.string_ = string;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.string)
+}
+inline ::substrait::Type_String* Type::_internal_mutable_string() {
+  if (!_internal_has_string()) {
+    clear_kind();
+    set_has_string();
+    kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArenaForAllocation());
+  }
+  return kind_.string_;
+}
+inline ::substrait::Type_String* Type::mutable_string() {
+  ::substrait::Type_String* _msg = _internal_mutable_string();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.string)
+  return _msg;
+}
+
+// .substrait.Type.Binary binary = 13;
+inline bool Type::_internal_has_binary() const {
+  return kind_case() == kBinary;
+}
+inline bool Type::has_binary() const {
+  return _internal_has_binary();
+}
+inline void Type::set_has_binary() {
+  _oneof_case_[0] = kBinary;
+}
+inline void Type::clear_binary() {
+  if (_internal_has_binary()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.binary_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_Binary* Type::release_binary() {
+  // @@protoc_insertion_point(field_release:substrait.Type.binary)
+  if (_internal_has_binary()) {
+    clear_has_kind();
+      ::substrait::Type_Binary* temp = kind_.binary_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.binary_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Binary& Type::_internal_binary() const {
+  return _internal_has_binary()
+      ? *kind_.binary_
+      : reinterpret_cast< ::substrait::Type_Binary&>(::substrait::_Type_Binary_default_instance_);
+}
+inline const ::substrait::Type_Binary& Type::binary() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.binary)
+  return _internal_binary();
+}
+inline ::substrait::Type_Binary* Type::unsafe_arena_release_binary() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.binary)
+  if (_internal_has_binary()) {
+    clear_has_kind();
+    ::substrait::Type_Binary* temp = kind_.binary_;
+    kind_.binary_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_binary(::substrait::Type_Binary* binary) {
+  clear_kind();
+  if (binary) {
+    set_has_binary();
+    kind_.binary_ = binary;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.binary)
+}
+inline ::substrait::Type_Binary* Type::_internal_mutable_binary() {
+  if (!_internal_has_binary()) {
+    clear_kind();
+    set_has_binary();
+    kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArenaForAllocation());
+  }
+  return kind_.binary_;
+}
+inline ::substrait::Type_Binary* Type::mutable_binary() {
+  ::substrait::Type_Binary* _msg = _internal_mutable_binary();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.binary)
+  return _msg;
+}
+
+// .substrait.Type.Timestamp timestamp = 14;
+inline bool Type::_internal_has_timestamp() const {
+  return kind_case() == kTimestamp;
+}
+inline bool Type::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void Type::set_has_timestamp() {
+  _oneof_case_[0] = kTimestamp;
+}
+inline void Type::clear_timestamp() {
+  if (_internal_has_timestamp()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.timestamp_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_Timestamp* Type::release_timestamp() {
+  // @@protoc_insertion_point(field_release:substrait.Type.timestamp)
+  if (_internal_has_timestamp()) {
+    clear_has_kind();
+      ::substrait::Type_Timestamp* temp = kind_.timestamp_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.timestamp_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Timestamp& Type::_internal_timestamp() const {
+  return _internal_has_timestamp()
+      ? *kind_.timestamp_
+      : reinterpret_cast< ::substrait::Type_Timestamp&>(::substrait::_Type_Timestamp_default_instance_);
+}
+inline const ::substrait::Type_Timestamp& Type::timestamp() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.timestamp)
+  return _internal_timestamp();
+}
+inline ::substrait::Type_Timestamp* Type::unsafe_arena_release_timestamp() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.timestamp)
+  if (_internal_has_timestamp()) {
+    clear_has_kind();
+    ::substrait::Type_Timestamp* temp = kind_.timestamp_;
+    kind_.timestamp_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) {
+  clear_kind();
+  if (timestamp) {
+    set_has_timestamp();
+    kind_.timestamp_ = timestamp;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.timestamp)
+}
+inline ::substrait::Type_Timestamp* Type::_internal_mutable_timestamp() {
+  if (!_internal_has_timestamp()) {
+    clear_kind();
+    set_has_timestamp();
+    kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArenaForAllocation());
+  }
+  return kind_.timestamp_;
+}
+inline ::substrait::Type_Timestamp* Type::mutable_timestamp() {
+  ::substrait::Type_Timestamp* _msg = _internal_mutable_timestamp();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.timestamp)
+  return _msg;
+}
+
+// .substrait.Type.Date date = 16;
+inline bool Type::_internal_has_date() const {
+  return kind_case() == kDate;
+}
+inline bool Type::has_date() const {
+  return _internal_has_date();
+}
+inline void Type::set_has_date() {
+  _oneof_case_[0] = kDate;
+}
+inline void Type::clear_date() {
+  if (_internal_has_date()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.date_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_Date* Type::release_date() {
+  // @@protoc_insertion_point(field_release:substrait.Type.date)
+  if (_internal_has_date()) {
+    clear_has_kind();
+      ::substrait::Type_Date* temp = kind_.date_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.date_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Date& Type::_internal_date() const {
+  return _internal_has_date()
+      ? *kind_.date_
+      : reinterpret_cast< ::substrait::Type_Date&>(::substrait::_Type_Date_default_instance_);
+}
+inline const ::substrait::Type_Date& Type::date() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.date)
+  return _internal_date();
+}
+inline ::substrait::Type_Date* Type::unsafe_arena_release_date() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.date)
+  if (_internal_has_date()) {
+    clear_has_kind();
+    ::substrait::Type_Date* temp = kind_.date_;
+    kind_.date_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_date(::substrait::Type_Date* date) {
+  clear_kind();
+  if (date) {
+    set_has_date();
+    kind_.date_ = date;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.date)
+}
+inline ::substrait::Type_Date* Type::_internal_mutable_date() {
+  if (!_internal_has_date()) {
+    clear_kind();
+    set_has_date();
+    kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArenaForAllocation());
+  }
+  return kind_.date_;
+}
+inline ::substrait::Type_Date* Type::mutable_date() {
+  ::substrait::Type_Date* _msg = _internal_mutable_date();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.date)
+  return _msg;
+}
+
+// .substrait.Type.Time time = 17;
+inline bool Type::_internal_has_time() const {
+  return kind_case() == kTime;
+}
+inline bool Type::has_time() const {
+  return _internal_has_time();
+}
+inline void Type::set_has_time() {
+  _oneof_case_[0] = kTime;
+}
+inline void Type::clear_time() {
+  if (_internal_has_time()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.time_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_Time* Type::release_time() {
+  // @@protoc_insertion_point(field_release:substrait.Type.time)
+  if (_internal_has_time()) {
+    clear_has_kind();
+      ::substrait::Type_Time* temp = kind_.time_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.time_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Time& Type::_internal_time() const {
+  return _internal_has_time()
+      ? *kind_.time_
+      : reinterpret_cast< ::substrait::Type_Time&>(::substrait::_Type_Time_default_instance_);
+}
+inline const ::substrait::Type_Time& Type::time() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.time)
+  return _internal_time();
+}
+inline ::substrait::Type_Time* Type::unsafe_arena_release_time() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.time)
+  if (_internal_has_time()) {
+    clear_has_kind();
+    ::substrait::Type_Time* temp = kind_.time_;
+    kind_.time_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_time(::substrait::Type_Time* time) {
+  clear_kind();
+  if (time) {
+    set_has_time();
+    kind_.time_ = time;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.time)
+}
+inline ::substrait::Type_Time* Type::_internal_mutable_time() {
+  if (!_internal_has_time()) {
+    clear_kind();
+    set_has_time();
+    kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArenaForAllocation());
+  }
+  return kind_.time_;
+}
+inline ::substrait::Type_Time* Type::mutable_time() {
+  ::substrait::Type_Time* _msg = _internal_mutable_time();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.time)
+  return _msg;
+}
+
+// .substrait.Type.IntervalYear interval_year = 19;
+inline bool Type::_internal_has_interval_year() const {
+  return kind_case() == kIntervalYear;
+}
+inline bool Type::has_interval_year() const {
+  return _internal_has_interval_year();
+}
+inline void Type::set_has_interval_year() {
+  _oneof_case_[0] = kIntervalYear;
+}
+inline void Type::clear_interval_year() {
+  if (_internal_has_interval_year()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.interval_year_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_IntervalYear* Type::release_interval_year() {
+  // @@protoc_insertion_point(field_release:substrait.Type.interval_year)
+  if (_internal_has_interval_year()) {
+    clear_has_kind();
+      ::substrait::Type_IntervalYear* temp = kind_.interval_year_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.interval_year_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_IntervalYear& Type::_internal_interval_year() const {
+  return _internal_has_interval_year()
+      ? *kind_.interval_year_
+      : reinterpret_cast< ::substrait::Type_IntervalYear&>(::substrait::_Type_IntervalYear_default_instance_);
+}
+inline const ::substrait::Type_IntervalYear& Type::interval_year() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.interval_year)
+  return _internal_interval_year();
+}
+inline ::substrait::Type_IntervalYear* Type::unsafe_arena_release_interval_year() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.interval_year)
+  if (_internal_has_interval_year()) {
+    clear_has_kind();
+    ::substrait::Type_IntervalYear* temp = kind_.interval_year_;
+    kind_.interval_year_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) {
+  clear_kind();
+  if (interval_year) {
+    set_has_interval_year();
+    kind_.interval_year_ = interval_year;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.interval_year)
+}
+inline ::substrait::Type_IntervalYear* Type::_internal_mutable_interval_year() {
+  if (!_internal_has_interval_year()) {
+    clear_kind();
+    set_has_interval_year();
+    kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArenaForAllocation());
+  }
+  return kind_.interval_year_;
+}
+inline ::substrait::Type_IntervalYear* Type::mutable_interval_year() {
+  ::substrait::Type_IntervalYear* _msg = _internal_mutable_interval_year();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.interval_year)
+  return _msg;
+}
+
+// .substrait.Type.IntervalDay interval_day = 20;
+inline bool Type::_internal_has_interval_day() const {
+  return kind_case() == kIntervalDay;
+}
+inline bool Type::has_interval_day() const {
+  return _internal_has_interval_day();
+}
+inline void Type::set_has_interval_day() {
+  _oneof_case_[0] = kIntervalDay;
+}
+inline void Type::clear_interval_day() {
+  if (_internal_has_interval_day()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.interval_day_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_IntervalDay* Type::release_interval_day() {
+  // @@protoc_insertion_point(field_release:substrait.Type.interval_day)
+  if (_internal_has_interval_day()) {
+    clear_has_kind();
+      ::substrait::Type_IntervalDay* temp = kind_.interval_day_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.interval_day_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_IntervalDay& Type::_internal_interval_day() const {
+  return _internal_has_interval_day()
+      ? *kind_.interval_day_
+      : reinterpret_cast< ::substrait::Type_IntervalDay&>(::substrait::_Type_IntervalDay_default_instance_);
+}
+inline const ::substrait::Type_IntervalDay& Type::interval_day() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.interval_day)
+  return _internal_interval_day();
+}
+inline ::substrait::Type_IntervalDay* Type::unsafe_arena_release_interval_day() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.interval_day)
+  if (_internal_has_interval_day()) {
+    clear_has_kind();
+    ::substrait::Type_IntervalDay* temp = kind_.interval_day_;
+    kind_.interval_day_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) {
+  clear_kind();
+  if (interval_day) {
+    set_has_interval_day();
+    kind_.interval_day_ = interval_day;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.interval_day)
+}
+inline ::substrait::Type_IntervalDay* Type::_internal_mutable_interval_day() {
+  if (!_internal_has_interval_day()) {
+    clear_kind();
+    set_has_interval_day();
+    kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArenaForAllocation());
+  }
+  return kind_.interval_day_;
+}
+inline ::substrait::Type_IntervalDay* Type::mutable_interval_day() {
+  ::substrait::Type_IntervalDay* _msg = _internal_mutable_interval_day();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.interval_day)
+  return _msg;
+}
+
+// .substrait.Type.TimestampTZ timestamp_tz = 29;
+inline bool Type::_internal_has_timestamp_tz() const {
+  return kind_case() == kTimestampTz;
+}
+inline bool Type::has_timestamp_tz() const {
+  return _internal_has_timestamp_tz();
+}
+inline void Type::set_has_timestamp_tz() {
+  _oneof_case_[0] = kTimestampTz;
+}
+inline void Type::clear_timestamp_tz() {
+  if (_internal_has_timestamp_tz()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.timestamp_tz_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_TimestampTZ* Type::release_timestamp_tz() {
+  // @@protoc_insertion_point(field_release:substrait.Type.timestamp_tz)
+  if (_internal_has_timestamp_tz()) {
+    clear_has_kind();
+      ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.timestamp_tz_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_TimestampTZ& Type::_internal_timestamp_tz() const {
+  return _internal_has_timestamp_tz()
+      ? *kind_.timestamp_tz_
+      : reinterpret_cast< ::substrait::Type_TimestampTZ&>(::substrait::_Type_TimestampTZ_default_instance_);
+}
+inline const ::substrait::Type_TimestampTZ& Type::timestamp_tz() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.timestamp_tz)
+  return _internal_timestamp_tz();
+}
+inline ::substrait::Type_TimestampTZ* Type::unsafe_arena_release_timestamp_tz() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.timestamp_tz)
+  if (_internal_has_timestamp_tz()) {
+    clear_has_kind();
+    ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_;
+    kind_.timestamp_tz_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) {
+  clear_kind();
+  if (timestamp_tz) {
+    set_has_timestamp_tz();
+    kind_.timestamp_tz_ = timestamp_tz;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.timestamp_tz)
+}
+inline ::substrait::Type_TimestampTZ* Type::_internal_mutable_timestamp_tz() {
+  if (!_internal_has_timestamp_tz()) {
+    clear_kind();
+    set_has_timestamp_tz();
+    kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArenaForAllocation());
+  }
+  return kind_.timestamp_tz_;
+}
+inline ::substrait::Type_TimestampTZ* Type::mutable_timestamp_tz() {
+  ::substrait::Type_TimestampTZ* _msg = _internal_mutable_timestamp_tz();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.timestamp_tz)
+  return _msg;
+}
+
+// .substrait.Type.UUID uuid = 32;
+inline bool Type::_internal_has_uuid() const {
+  return kind_case() == kUuid;
+}
+inline bool Type::has_uuid() const {
+  return _internal_has_uuid();
+}
+inline void Type::set_has_uuid() {
+  _oneof_case_[0] = kUuid;
+}
+inline void Type::clear_uuid() {
+  if (_internal_has_uuid()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.uuid_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_UUID* Type::release_uuid() {
+  // @@protoc_insertion_point(field_release:substrait.Type.uuid)
+  if (_internal_has_uuid()) {
+    clear_has_kind();
+      ::substrait::Type_UUID* temp = kind_.uuid_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.uuid_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_UUID& Type::_internal_uuid() const {
+  return _internal_has_uuid()
+      ? *kind_.uuid_
+      : reinterpret_cast< ::substrait::Type_UUID&>(::substrait::_Type_UUID_default_instance_);
+}
+inline const ::substrait::Type_UUID& Type::uuid() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.uuid)
+  return _internal_uuid();
+}
+inline ::substrait::Type_UUID* Type::unsafe_arena_release_uuid() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.uuid)
+  if (_internal_has_uuid()) {
+    clear_has_kind();
+    ::substrait::Type_UUID* temp = kind_.uuid_;
+    kind_.uuid_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_uuid(::substrait::Type_UUID* uuid) {
+  clear_kind();
+  if (uuid) {
+    set_has_uuid();
+    kind_.uuid_ = uuid;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.uuid)
+}
+inline ::substrait::Type_UUID* Type::_internal_mutable_uuid() {
+  if (!_internal_has_uuid()) {
+    clear_kind();
+    set_has_uuid();
+    kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArenaForAllocation());
+  }
+  return kind_.uuid_;
+}
+inline ::substrait::Type_UUID* Type::mutable_uuid() {
+  ::substrait::Type_UUID* _msg = _internal_mutable_uuid();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.uuid)
+  return _msg;
+}
+
+// .substrait.Type.FixedChar fixed_char = 21;
+inline bool Type::_internal_has_fixed_char() const {
+  return kind_case() == kFixedChar;
+}
+inline bool Type::has_fixed_char() const {
+  return _internal_has_fixed_char();
+}
+inline void Type::set_has_fixed_char() {
+  _oneof_case_[0] = kFixedChar;
+}
+inline void Type::clear_fixed_char() {
+  if (_internal_has_fixed_char()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.fixed_char_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_FixedChar* Type::release_fixed_char() {
+  // @@protoc_insertion_point(field_release:substrait.Type.fixed_char)
+  if (_internal_has_fixed_char()) {
+    clear_has_kind();
+      ::substrait::Type_FixedChar* temp = kind_.fixed_char_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.fixed_char_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_FixedChar& Type::_internal_fixed_char() const {
+  return _internal_has_fixed_char()
+      ? *kind_.fixed_char_
+      : reinterpret_cast< ::substrait::Type_FixedChar&>(::substrait::_Type_FixedChar_default_instance_);
+}
+inline const ::substrait::Type_FixedChar& Type::fixed_char() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.fixed_char)
+  return _internal_fixed_char();
+}
+inline ::substrait::Type_FixedChar* Type::unsafe_arena_release_fixed_char() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.fixed_char)
+  if (_internal_has_fixed_char()) {
+    clear_has_kind();
+    ::substrait::Type_FixedChar* temp = kind_.fixed_char_;
+    kind_.fixed_char_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_fixed_char(::substrait::Type_FixedChar* fixed_char) {
+  clear_kind();
+  if (fixed_char) {
+    set_has_fixed_char();
+    kind_.fixed_char_ = fixed_char;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.fixed_char)
+}
+inline ::substrait::Type_FixedChar* Type::_internal_mutable_fixed_char() {
+  if (!_internal_has_fixed_char()) {
+    clear_kind();
+    set_has_fixed_char();
+    kind_.fixed_char_ = CreateMaybeMessage< ::substrait::Type_FixedChar >(GetArenaForAllocation());
+  }
+  return kind_.fixed_char_;
+}
+inline ::substrait::Type_FixedChar* Type::mutable_fixed_char() {
+  ::substrait::Type_FixedChar* _msg = _internal_mutable_fixed_char();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.fixed_char)
+  return _msg;
+}
+
+// .substrait.Type.VarChar varchar = 22;
+inline bool Type::_internal_has_varchar() const {
+  return kind_case() == kVarchar;
+}
+inline bool Type::has_varchar() const {
+  return _internal_has_varchar();
+}
+inline void Type::set_has_varchar() {
+  _oneof_case_[0] = kVarchar;
+}
+inline void Type::clear_varchar() {
+  if (_internal_has_varchar()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.varchar_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_VarChar* Type::release_varchar() {
+  // @@protoc_insertion_point(field_release:substrait.Type.varchar)
+  if (_internal_has_varchar()) {
+    clear_has_kind();
+      ::substrait::Type_VarChar* temp = kind_.varchar_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.varchar_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_VarChar& Type::_internal_varchar() const {
+  return _internal_has_varchar()
+      ? *kind_.varchar_
+      : reinterpret_cast< ::substrait::Type_VarChar&>(::substrait::_Type_VarChar_default_instance_);
+}
+inline const ::substrait::Type_VarChar& Type::varchar() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.varchar)
+  return _internal_varchar();
+}
+inline ::substrait::Type_VarChar* Type::unsafe_arena_release_varchar() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.varchar)
+  if (_internal_has_varchar()) {
+    clear_has_kind();
+    ::substrait::Type_VarChar* temp = kind_.varchar_;
+    kind_.varchar_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_varchar(::substrait::Type_VarChar* varchar) {
+  clear_kind();
+  if (varchar) {
+    set_has_varchar();
+    kind_.varchar_ = varchar;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.varchar)
+}
+inline ::substrait::Type_VarChar* Type::_internal_mutable_varchar() {
+  if (!_internal_has_varchar()) {
+    clear_kind();
+    set_has_varchar();
+    kind_.varchar_ = CreateMaybeMessage< ::substrait::Type_VarChar >(GetArenaForAllocation());
+  }
+  return kind_.varchar_;
+}
+inline ::substrait::Type_VarChar* Type::mutable_varchar() {
+  ::substrait::Type_VarChar* _msg = _internal_mutable_varchar();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.varchar)
+  return _msg;
+}
+
+// .substrait.Type.FixedBinary fixed_binary = 23;
+inline bool Type::_internal_has_fixed_binary() const {
+  return kind_case() == kFixedBinary;
+}
+inline bool Type::has_fixed_binary() const {
+  return _internal_has_fixed_binary();
+}
+inline void Type::set_has_fixed_binary() {
+  _oneof_case_[0] = kFixedBinary;
+}
+inline void Type::clear_fixed_binary() {
+  if (_internal_has_fixed_binary()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.fixed_binary_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_FixedBinary* Type::release_fixed_binary() {
+  // @@protoc_insertion_point(field_release:substrait.Type.fixed_binary)
+  if (_internal_has_fixed_binary()) {
+    clear_has_kind();
+      ::substrait::Type_FixedBinary* temp = kind_.fixed_binary_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.fixed_binary_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_FixedBinary& Type::_internal_fixed_binary() const {
+  return _internal_has_fixed_binary()
+      ? *kind_.fixed_binary_
+      : reinterpret_cast< ::substrait::Type_FixedBinary&>(::substrait::_Type_FixedBinary_default_instance_);
+}
+inline const ::substrait::Type_FixedBinary& Type::fixed_binary() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.fixed_binary)
+  return _internal_fixed_binary();
+}
+inline ::substrait::Type_FixedBinary* Type::unsafe_arena_release_fixed_binary() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.fixed_binary)
+  if (_internal_has_fixed_binary()) {
+    clear_has_kind();
+    ::substrait::Type_FixedBinary* temp = kind_.fixed_binary_;
+    kind_.fixed_binary_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_fixed_binary(::substrait::Type_FixedBinary* fixed_binary) {
+  clear_kind();
+  if (fixed_binary) {
+    set_has_fixed_binary();
+    kind_.fixed_binary_ = fixed_binary;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.fixed_binary)
+}
+inline ::substrait::Type_FixedBinary* Type::_internal_mutable_fixed_binary() {
+  if (!_internal_has_fixed_binary()) {
+    clear_kind();
+    set_has_fixed_binary();
+    kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::Type_FixedBinary >(GetArenaForAllocation());
+  }
+  return kind_.fixed_binary_;
+}
+inline ::substrait::Type_FixedBinary* Type::mutable_fixed_binary() {
+  ::substrait::Type_FixedBinary* _msg = _internal_mutable_fixed_binary();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.fixed_binary)
+  return _msg;
+}
+
+// .substrait.Type.Decimal decimal = 24;
+inline bool Type::_internal_has_decimal() const {
+  return kind_case() == kDecimal;
+}
+inline bool Type::has_decimal() const {
+  return _internal_has_decimal();
+}
+inline void Type::set_has_decimal() {
+  _oneof_case_[0] = kDecimal;
+}
+inline void Type::clear_decimal() {
+  if (_internal_has_decimal()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.decimal_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_Decimal* Type::release_decimal() {
+  // @@protoc_insertion_point(field_release:substrait.Type.decimal)
+  if (_internal_has_decimal()) {
+    clear_has_kind();
+      ::substrait::Type_Decimal* temp = kind_.decimal_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.decimal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Decimal& Type::_internal_decimal() const {
+  return _internal_has_decimal()
+      ? *kind_.decimal_
+      : reinterpret_cast< ::substrait::Type_Decimal&>(::substrait::_Type_Decimal_default_instance_);
+}
+inline const ::substrait::Type_Decimal& Type::decimal() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.decimal)
+  return _internal_decimal();
+}
+inline ::substrait::Type_Decimal* Type::unsafe_arena_release_decimal() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.decimal)
+  if (_internal_has_decimal()) {
+    clear_has_kind();
+    ::substrait::Type_Decimal* temp = kind_.decimal_;
+    kind_.decimal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_decimal(::substrait::Type_Decimal* decimal) {
+  clear_kind();
+  if (decimal) {
+    set_has_decimal();
+    kind_.decimal_ = decimal;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.decimal)
+}
+inline ::substrait::Type_Decimal* Type::_internal_mutable_decimal() {
+  if (!_internal_has_decimal()) {
+    clear_kind();
+    set_has_decimal();
+    kind_.decimal_ = CreateMaybeMessage< ::substrait::Type_Decimal >(GetArenaForAllocation());
+  }
+  return kind_.decimal_;
+}
+inline ::substrait::Type_Decimal* Type::mutable_decimal() {
+  ::substrait::Type_Decimal* _msg = _internal_mutable_decimal();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.decimal)
+  return _msg;
+}
+
+// .substrait.Type.Struct struct = 25;
+inline bool Type::_internal_has_struct_() const {
+  return kind_case() == kStruct;
+}
+inline bool Type::has_struct_() const {
+  return _internal_has_struct_();
+}
+inline void Type::set_has_struct_() {
+  _oneof_case_[0] = kStruct;
+}
+inline void Type::clear_struct_() {
+  if (_internal_has_struct_()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.struct__;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_Struct* Type::release_struct_() {
+  // @@protoc_insertion_point(field_release:substrait.Type.struct)
+  if (_internal_has_struct_()) {
+    clear_has_kind();
+      ::substrait::Type_Struct* temp = kind_.struct__;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.struct__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Struct& Type::_internal_struct_() const {
+  return _internal_has_struct_()
+      ? *kind_.struct__
+      : reinterpret_cast< ::substrait::Type_Struct&>(::substrait::_Type_Struct_default_instance_);
+}
+inline const ::substrait::Type_Struct& Type::struct_() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.struct)
+  return _internal_struct_();
+}
+inline ::substrait::Type_Struct* Type::unsafe_arena_release_struct_() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.struct)
+  if (_internal_has_struct_()) {
+    clear_has_kind();
+    ::substrait::Type_Struct* temp = kind_.struct__;
+    kind_.struct__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_struct_(::substrait::Type_Struct* struct_) {
+  clear_kind();
+  if (struct_) {
+    set_has_struct_();
+    kind_.struct__ = struct_;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.struct)
+}
+inline ::substrait::Type_Struct* Type::_internal_mutable_struct_() {
+  if (!_internal_has_struct_()) {
+    clear_kind();
+    set_has_struct_();
+    kind_.struct__ = CreateMaybeMessage< ::substrait::Type_Struct >(GetArenaForAllocation());
+  }
+  return kind_.struct__;
+}
+inline ::substrait::Type_Struct* Type::mutable_struct_() {
+  ::substrait::Type_Struct* _msg = _internal_mutable_struct_();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.struct)
+  return _msg;
+}
+
+// .substrait.Type.List list = 27;
+inline bool Type::_internal_has_list() const {
+  return kind_case() == kList;
+}
+inline bool Type::has_list() const {
+  return _internal_has_list();
+}
+inline void Type::set_has_list() {
+  _oneof_case_[0] = kList;
+}
+inline void Type::clear_list() {
+  if (_internal_has_list()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.list_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_List* Type::release_list() {
+  // @@protoc_insertion_point(field_release:substrait.Type.list)
+  if (_internal_has_list()) {
+    clear_has_kind();
+      ::substrait::Type_List* temp = kind_.list_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_List& Type::_internal_list() const {
+  return _internal_has_list()
+      ? *kind_.list_
+      : reinterpret_cast< ::substrait::Type_List&>(::substrait::_Type_List_default_instance_);
+}
+inline const ::substrait::Type_List& Type::list() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.list)
+  return _internal_list();
+}
+inline ::substrait::Type_List* Type::unsafe_arena_release_list() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.list)
+  if (_internal_has_list()) {
+    clear_has_kind();
+    ::substrait::Type_List* temp = kind_.list_;
+    kind_.list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_list(::substrait::Type_List* list) {
+  clear_kind();
+  if (list) {
+    set_has_list();
+    kind_.list_ = list;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.list)
+}
+inline ::substrait::Type_List* Type::_internal_mutable_list() {
+  if (!_internal_has_list()) {
+    clear_kind();
+    set_has_list();
+    kind_.list_ = CreateMaybeMessage< ::substrait::Type_List >(GetArenaForAllocation());
+  }
+  return kind_.list_;
+}
+inline ::substrait::Type_List* Type::mutable_list() {
+  ::substrait::Type_List* _msg = _internal_mutable_list();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.list)
+  return _msg;
+}
+
+// .substrait.Type.Map map = 28;
+inline bool Type::_internal_has_map() const {
+  return kind_case() == kMap;
+}
+inline bool Type::has_map() const {
+  return _internal_has_map();
+}
+inline void Type::set_has_map() {
+  _oneof_case_[0] = kMap;
+}
+inline void Type::clear_map() {
+  if (_internal_has_map()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.map_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::Type_Map* Type::release_map() {
+  // @@protoc_insertion_point(field_release:substrait.Type.map)
+  if (_internal_has_map()) {
+    clear_has_kind();
+      ::substrait::Type_Map* temp = kind_.map_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.map_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Map& Type::_internal_map() const {
+  return _internal_has_map()
+      ? *kind_.map_
+      : reinterpret_cast< ::substrait::Type_Map&>(::substrait::_Type_Map_default_instance_);
+}
+inline const ::substrait::Type_Map& Type::map() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.map)
+  return _internal_map();
+}
+inline ::substrait::Type_Map* Type::unsafe_arena_release_map() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.map)
+  if (_internal_has_map()) {
+    clear_has_kind();
+    ::substrait::Type_Map* temp = kind_.map_;
+    kind_.map_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void Type::unsafe_arena_set_allocated_map(::substrait::Type_Map* map) {
+  clear_kind();
+  if (map) {
+    set_has_map();
+    kind_.map_ = map;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.map)
+}
+inline ::substrait::Type_Map* Type::_internal_mutable_map() {
+  if (!_internal_has_map()) {
+    clear_kind();
+    set_has_map();
+    kind_.map_ = CreateMaybeMessage< ::substrait::Type_Map >(GetArenaForAllocation());
+  }
+  return kind_.map_;
+}
+inline ::substrait::Type_Map* Type::mutable_map() {
+  ::substrait::Type_Map* _msg = _internal_mutable_map();
+  // @@protoc_insertion_point(field_mutable:substrait.Type.map)
+  return _msg;
+}
+
+// uint32 user_defined_type_reference = 31;
+inline bool Type::_internal_has_user_defined_type_reference() const {
+  return kind_case() == kUserDefinedTypeReference;
+}
+inline bool Type::has_user_defined_type_reference() const {
+  return _internal_has_user_defined_type_reference();
+}
+inline void Type::set_has_user_defined_type_reference() {
+  _oneof_case_[0] = kUserDefinedTypeReference;
+}
+inline void Type::clear_user_defined_type_reference() {
+  if (_internal_has_user_defined_type_reference()) {
+    kind_.user_defined_type_reference_ = 0u;
+    clear_has_kind();
+  }
+}
+inline uint32_t Type::_internal_user_defined_type_reference() const {
+  if (_internal_has_user_defined_type_reference()) {
+    return kind_.user_defined_type_reference_;
+  }
+  return 0u;
+}
+inline void Type::_internal_set_user_defined_type_reference(uint32_t value) {
+  if (!_internal_has_user_defined_type_reference()) {
+    clear_kind();
+    set_has_user_defined_type_reference();
+  }
+  kind_.user_defined_type_reference_ = value;
+}
+inline uint32_t Type::user_defined_type_reference() const {
+  // @@protoc_insertion_point(field_get:substrait.Type.user_defined_type_reference)
+  return _internal_user_defined_type_reference();
+}
+inline void Type::set_user_defined_type_reference(uint32_t value) {
+  _internal_set_user_defined_type_reference(value);
+  // @@protoc_insertion_point(field_set:substrait.Type.user_defined_type_reference)
+}
+
+inline bool Type::has_kind() const {
+  return kind_case() != KIND_NOT_SET;
+}
+inline void Type::clear_has_kind() {
+  _oneof_case_[0] = KIND_NOT_SET;
+}
+inline Type::KindCase Type::kind_case() const {
+  return Type::KindCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// NamedStruct
+
+// repeated string names = 1;
+inline int NamedStruct::_internal_names_size() const {
+  return names_.size();
+}
+inline int NamedStruct::names_size() const {
+  return _internal_names_size();
+}
+inline void NamedStruct::clear_names() {
+  names_.Clear();
+}
+inline std::string* NamedStruct::add_names() {
+  std::string* _s = _internal_add_names();
+  // @@protoc_insertion_point(field_add_mutable:substrait.NamedStruct.names)
+  return _s;
+}
+inline const std::string& NamedStruct::_internal_names(int index) const {
+  return names_.Get(index);
+}
+inline const std::string& NamedStruct::names(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.NamedStruct.names)
+  return _internal_names(index);
+}
+inline std::string* NamedStruct::mutable_names(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.NamedStruct.names)
+  return names_.Mutable(index);
+}
+inline void NamedStruct::set_names(int index, const std::string& value) {
+  names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.NamedStruct.names)
+}
+inline void NamedStruct::set_names(int index, std::string&& value) {
+  names_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.NamedStruct.names)
+}
+inline void NamedStruct::set_names(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.NamedStruct.names)
+}
+inline void NamedStruct::set_names(int index, const char* value, size_t size) {
+  names_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.NamedStruct.names)
+}
+inline std::string* NamedStruct::_internal_add_names() {
+  return names_.Add();
+}
+inline void NamedStruct::add_names(const std::string& value) {
+  names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.NamedStruct.names)
+}
+inline void NamedStruct::add_names(std::string&& value) {
+  names_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.NamedStruct.names)
+}
+inline void NamedStruct::add_names(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.NamedStruct.names)
+}
+inline void NamedStruct::add_names(const char* value, size_t size) {
+  names_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.NamedStruct.names)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+NamedStruct::names() const {
+  // @@protoc_insertion_point(field_list:substrait.NamedStruct.names)
+  return names_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+NamedStruct::mutable_names() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.NamedStruct.names)
+  return &names_;
+}
+
+// .substrait.Type.Struct struct = 2;
+inline bool NamedStruct::_internal_has_struct_() const {
+  return this != internal_default_instance() && struct__ != nullptr;
+}
+inline bool NamedStruct::has_struct_() const {
+  return _internal_has_struct_();
+}
+inline void NamedStruct::clear_struct_() {
+  if (GetArenaForAllocation() == nullptr && struct__ != nullptr) {
+    delete struct__;
+  }
+  struct__ = nullptr;
+}
+inline const ::substrait::Type_Struct& NamedStruct::_internal_struct_() const {
+  const ::substrait::Type_Struct* p = struct__;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::Type_Struct&>(
+      ::substrait::_Type_Struct_default_instance_);
+}
+inline const ::substrait::Type_Struct& NamedStruct::struct_() const {
+  // @@protoc_insertion_point(field_get:substrait.NamedStruct.struct)
+  return _internal_struct_();
+}
+inline void NamedStruct::unsafe_arena_set_allocated_struct_(
+    ::substrait::Type_Struct* struct_) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__);
+  }
+  struct__ = struct_;
+  if (struct_) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.NamedStruct.struct)
+}
+inline ::substrait::Type_Struct* NamedStruct::release_struct_() {
+  
+  ::substrait::Type_Struct* temp = struct__;
+  struct__ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::Type_Struct* NamedStruct::unsafe_arena_release_struct_() {
+  // @@protoc_insertion_point(field_release:substrait.NamedStruct.struct)
+  
+  ::substrait::Type_Struct* temp = struct__;
+  struct__ = nullptr;
+  return temp;
+}
+inline ::substrait::Type_Struct* NamedStruct::_internal_mutable_struct_() {
+  
+  if (struct__ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::Type_Struct>(GetArenaForAllocation());
+    struct__ = p;
+  }
+  return struct__;
+}
+inline ::substrait::Type_Struct* NamedStruct::mutable_struct_() {
+  ::substrait::Type_Struct* _msg = _internal_mutable_struct_();
+  // @@protoc_insertion_point(field_mutable:substrait.NamedStruct.struct)
+  return _msg;
+}
+inline void NamedStruct::set_allocated_struct_(::substrait::Type_Struct* struct_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete struct__;
+  }
+  if (struct_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Struct>::GetOwningArena(struct_);
+    if (message_arena != submessage_arena) {
+      struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, struct_, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  struct__ = struct_;
+  // @@protoc_insertion_point(field_set_allocated:substrait.NamedStruct.struct)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace substrait
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::substrait::Type_Nullability> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::substrait::Type_Nullability>() {
+  return ::substrait::Type_Nullability_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_2eproto
diff --git a/cpp/src/generated/substrait/type_expressions.pb.cc b/cpp/src/generated/substrait/type_expressions.pb.cc
new file mode 100644
index 000000000000..1179ab8e3adb
--- /dev/null
+++ b/cpp/src/generated/substrait/type_expressions.pb.cc
@@ -0,0 +1,6038 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/type_expressions.proto
+
+#include "substrait/type_expressions.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace substrait {
+constexpr DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : length_(nullptr)
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct DerivationExpression_ExpressionFixedCharDefaultTypeInternal {
+  constexpr DerivationExpression_ExpressionFixedCharDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_ExpressionFixedCharDefaultTypeInternal() {}
+  union {
+    DerivationExpression_ExpressionFixedChar _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionFixedCharDefaultTypeInternal _DerivationExpression_ExpressionFixedChar_default_instance_;
+constexpr DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : length_(nullptr)
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct DerivationExpression_ExpressionVarCharDefaultTypeInternal {
+  constexpr DerivationExpression_ExpressionVarCharDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_ExpressionVarCharDefaultTypeInternal() {}
+  union {
+    DerivationExpression_ExpressionVarChar _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionVarCharDefaultTypeInternal _DerivationExpression_ExpressionVarChar_default_instance_;
+constexpr DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : length_(nullptr)
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal {
+  constexpr DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal() {}
+  union {
+    DerivationExpression_ExpressionFixedBinary _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal _DerivationExpression_ExpressionFixedBinary_default_instance_;
+constexpr DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : scale_(nullptr)
+  , precision_(nullptr)
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct DerivationExpression_ExpressionDecimalDefaultTypeInternal {
+  constexpr DerivationExpression_ExpressionDecimalDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_ExpressionDecimalDefaultTypeInternal() {}
+  union {
+    DerivationExpression_ExpressionDecimal _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionDecimalDefaultTypeInternal _DerivationExpression_ExpressionDecimal_default_instance_;
+constexpr DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : types_()
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct DerivationExpression_ExpressionStructDefaultTypeInternal {
+  constexpr DerivationExpression_ExpressionStructDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_ExpressionStructDefaultTypeInternal() {}
+  union {
+    DerivationExpression_ExpressionStruct _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionStructDefaultTypeInternal _DerivationExpression_ExpressionStruct_default_instance_;
+constexpr DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : names_()
+  , struct__(nullptr){}
+struct DerivationExpression_ExpressionNamedStructDefaultTypeInternal {
+  constexpr DerivationExpression_ExpressionNamedStructDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_ExpressionNamedStructDefaultTypeInternal() {}
+  union {
+    DerivationExpression_ExpressionNamedStruct _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionNamedStructDefaultTypeInternal _DerivationExpression_ExpressionNamedStruct_default_instance_;
+constexpr DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_(nullptr)
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct DerivationExpression_ExpressionListDefaultTypeInternal {
+  constexpr DerivationExpression_ExpressionListDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_ExpressionListDefaultTypeInternal() {}
+  union {
+    DerivationExpression_ExpressionList _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionListDefaultTypeInternal _DerivationExpression_ExpressionList_default_instance_;
+constexpr DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : key_(nullptr)
+  , value_(nullptr)
+  , variation_pointer_(0u)
+  , nullability_(0)
+{}
+struct DerivationExpression_ExpressionMapDefaultTypeInternal {
+  constexpr DerivationExpression_ExpressionMapDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_ExpressionMapDefaultTypeInternal() {}
+  union {
+    DerivationExpression_ExpressionMap _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionMapDefaultTypeInternal _DerivationExpression_ExpressionMap_default_instance_;
+constexpr DerivationExpression_IfElse::DerivationExpression_IfElse(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : if_condition_(nullptr)
+  , if_return_(nullptr)
+  , else_return_(nullptr){}
+struct DerivationExpression_IfElseDefaultTypeInternal {
+  constexpr DerivationExpression_IfElseDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_IfElseDefaultTypeInternal() {}
+  union {
+    DerivationExpression_IfElse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_IfElseDefaultTypeInternal _DerivationExpression_IfElse_default_instance_;
+constexpr DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : arg_(nullptr)
+  , op_type_(0)
+{}
+struct DerivationExpression_UnaryOpDefaultTypeInternal {
+  constexpr DerivationExpression_UnaryOpDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_UnaryOpDefaultTypeInternal() {}
+  union {
+    DerivationExpression_UnaryOp _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_UnaryOpDefaultTypeInternal _DerivationExpression_UnaryOp_default_instance_;
+constexpr DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : arg1_(nullptr)
+  , arg2_(nullptr)
+  , op_type_(0)
+{}
+struct DerivationExpression_BinaryOpDefaultTypeInternal {
+  constexpr DerivationExpression_BinaryOpDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_BinaryOpDefaultTypeInternal() {}
+  union {
+    DerivationExpression_BinaryOp _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_BinaryOpDefaultTypeInternal _DerivationExpression_BinaryOp_default_instance_;
+constexpr DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+  , expression_(nullptr){}
+struct DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal {
+  constexpr DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal() {}
+  union {
+    DerivationExpression_ReturnProgram_Assignment _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal _DerivationExpression_ReturnProgram_Assignment_default_instance_;
+constexpr DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : assignments_()
+  , final_expression_(nullptr){}
+struct DerivationExpression_ReturnProgramDefaultTypeInternal {
+  constexpr DerivationExpression_ReturnProgramDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpression_ReturnProgramDefaultTypeInternal() {}
+  union {
+    DerivationExpression_ReturnProgram _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ReturnProgramDefaultTypeInternal _DerivationExpression_ReturnProgram_default_instance_;
+constexpr DerivationExpression::DerivationExpression(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : _oneof_case_{}{}
+struct DerivationExpressionDefaultTypeInternal {
+  constexpr DerivationExpressionDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~DerivationExpressionDefaultTypeInternal() {}
+  union {
+    DerivationExpression _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpressionDefaultTypeInternal _DerivationExpression_default_instance_;
+}  // namespace substrait
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ftype_5fexpressions_2eproto[14];
+static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[2];
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ftype_5fexpressions_2eproto = nullptr;
+
+const uint32_t TableStruct_substrait_2ftype_5fexpressions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, length_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, length_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, length_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, scale_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, precision_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, types_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, names_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, struct__),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, key_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, value_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, variation_pointer_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, nullability_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, if_condition_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, if_return_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, else_return_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, op_type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, arg_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, op_type_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, arg1_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, arg2_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, name_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, expression_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, assignments_),
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, final_expression_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, _internal_metadata_),
+  ~0u,  // no _extensions_
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, _oneof_case_[0]),
+  ~0u,  // no _weak_field_map_
+  ~0u,  // no _inlined_string_donated_
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+  PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, kind_),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionFixedChar)},
+  { 9, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionVarChar)},
+  { 18, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionFixedBinary)},
+  { 27, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionDecimal)},
+  { 37, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionStruct)},
+  { 46, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionNamedStruct)},
+  { 54, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionList)},
+  { 63, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionMap)},
+  { 73, -1, -1, sizeof(::substrait::DerivationExpression_IfElse)},
+  { 82, -1, -1, sizeof(::substrait::DerivationExpression_UnaryOp)},
+  { 90, -1, -1, sizeof(::substrait::DerivationExpression_BinaryOp)},
+  { 99, -1, -1, sizeof(::substrait::DerivationExpression_ReturnProgram_Assignment)},
+  { 107, -1, -1, sizeof(::substrait::DerivationExpression_ReturnProgram)},
+  { 115, -1, -1, sizeof(::substrait::DerivationExpression)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionVarChar_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionDecimal_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionStruct_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionNamedStruct_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionList_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ExpressionMap_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_IfElse_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_UnaryOp_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_BinaryOp_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ReturnProgram_Assignment_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_ReturnProgram_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::substrait::_DerivationExpression_default_instance_),
+};
+
+const char descriptor_table_protodef_substrait_2ftype_5fexpressions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n substrait/type_expressions.proto\022\tsubs"
+  "trait\032\024substrait/type.proto\"\366\036\n\024Derivati"
+  "onExpression\022\'\n\004bool\030\001 \001(\0132\027.substrait.T"
+  "ype.BooleanH\000\022 \n\002i8\030\002 \001(\0132\022.substrait.Ty"
+  "pe.I8H\000\022\"\n\003i16\030\003 \001(\0132\023.substrait.Type.I1"
+  "6H\000\022\"\n\003i32\030\005 \001(\0132\023.substrait.Type.I32H\000\022"
+  "\"\n\003i64\030\007 \001(\0132\023.substrait.Type.I64H\000\022$\n\004f"
+  "p32\030\n \001(\0132\024.substrait.Type.FP32H\000\022$\n\004fp6"
+  "4\030\013 \001(\0132\024.substrait.Type.FP64H\000\022(\n\006strin"
+  "g\030\014 \001(\0132\026.substrait.Type.StringH\000\022(\n\006bin"
+  "ary\030\r \001(\0132\026.substrait.Type.BinaryH\000\022.\n\tt"
+  "imestamp\030\016 \001(\0132\031.substrait.Type.Timestam"
+  "pH\000\022$\n\004date\030\020 \001(\0132\024.substrait.Type.DateH"
+  "\000\022$\n\004time\030\021 \001(\0132\024.substrait.Type.TimeH\000\022"
+  "5\n\rinterval_year\030\023 \001(\0132\034.substrait.Type."
+  "IntervalYearH\000\0223\n\014interval_day\030\024 \001(\0132\033.s"
+  "ubstrait.Type.IntervalDayH\000\0223\n\014timestamp"
+  "_tz\030\035 \001(\0132\033.substrait.Type.TimestampTZH\000"
+  "\022$\n\004uuid\030  \001(\0132\024.substrait.Type.UUIDH\000\022I"
+  "\n\nfixed_char\030\025 \001(\01323.substrait.Derivatio"
+  "nExpression.ExpressionFixedCharH\000\022D\n\007var"
+  "char\030\026 \001(\01321.substrait.DerivationExpress"
+  "ion.ExpressionVarCharH\000\022M\n\014fixed_binary\030"
+  "\027 \001(\01325.substrait.DerivationExpression.E"
+  "xpressionFixedBinaryH\000\022D\n\007decimal\030\030 \001(\0132"
+  "1.substrait.DerivationExpression.Express"
+  "ionDecimalH\000\022B\n\006struct\030\031 \001(\01320.substrait"
+  ".DerivationExpression.ExpressionStructH\000"
+  "\022>\n\004list\030\033 \001(\0132..substrait.DerivationExp"
+  "ression.ExpressionListH\000\022<\n\003map\030\034 \001(\0132-."
+  "substrait.DerivationExpression.Expressio"
+  "nMapH\000\022\036\n\024user_defined_pointer\030\037 \001(\rH\000\022\035"
+  "\n\023type_parameter_name\030! \001(\tH\000\022 \n\026integer"
+  "_parameter_name\030\" \001(\tH\000\022\031\n\017integer_liter"
+  "al\030# \001(\005H\000\022;\n\010unary_op\030$ \001(\0132\'.substrait"
+  ".DerivationExpression.UnaryOpH\000\022=\n\tbinar"
+  "y_op\030% \001(\0132(.substrait.DerivationExpress"
+  "ion.BinaryOpH\000\0229\n\007if_else\030& \001(\0132&.substr"
+  "ait.DerivationExpression.IfElseH\000\022G\n\016ret"
+  "urn_program\030\' \001(\0132-.substrait.Derivation"
+  "Expression.ReturnProgramH\000\032\223\001\n\023Expressio"
+  "nFixedChar\022/\n\006length\030\001 \001(\0132\037.substrait.D"
+  "erivationExpression\022\031\n\021variation_pointer"
+  "\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033.substrait."
+  "Type.Nullability\032\221\001\n\021ExpressionVarChar\022/"
+  "\n\006length\030\001 \001(\0132\037.substrait.DerivationExp"
+  "ression\022\031\n\021variation_pointer\030\002 \001(\r\0220\n\013nu"
+  "llability\030\003 \001(\0162\033.substrait.Type.Nullabi"
+  "lity\032\225\001\n\025ExpressionFixedBinary\022/\n\006length"
+  "\030\001 \001(\0132\037.substrait.DerivationExpression\022"
+  "\031\n\021variation_pointer\030\002 \001(\r\0220\n\013nullabilit"
+  "y\030\003 \001(\0162\033.substrait.Type.Nullability\032\304\001\n"
+  "\021ExpressionDecimal\022.\n\005scale\030\001 \001(\0132\037.subs"
+  "trait.DerivationExpression\0222\n\tprecision\030"
+  "\002 \001(\0132\037.substrait.DerivationExpression\022\031"
+  "\n\021variation_pointer\030\003 \001(\r\0220\n\013nullability"
+  "\030\004 \001(\0162\033.substrait.Type.Nullability\032\217\001\n\020"
+  "ExpressionStruct\022.\n\005types\030\001 \003(\0132\037.substr"
+  "ait.DerivationExpression\022\031\n\021variation_po"
+  "inter\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033.subst"
+  "rait.Type.Nullability\032h\n\025ExpressionNamed"
+  "Struct\022\r\n\005names\030\001 \003(\t\022@\n\006struct\030\002 \001(\01320."
+  "substrait.DerivationExpression.Expressio"
+  "nStruct\032\214\001\n\016ExpressionList\022-\n\004type\030\001 \001(\013"
+  "2\037.substrait.DerivationExpression\022\031\n\021var"
+  "iation_pointer\030\002 \001(\r\0220\n\013nullability\030\003 \001("
+  "\0162\033.substrait.Type.Nullability\032\272\001\n\rExpre"
+  "ssionMap\022,\n\003key\030\001 \001(\0132\037.substrait.Deriva"
+  "tionExpression\022.\n\005value\030\002 \001(\0132\037.substrai"
+  "t.DerivationExpression\022\031\n\021variation_poin"
+  "ter\030\003 \001(\r\0220\n\013nullability\030\004 \001(\0162\033.substra"
+  "it.Type.Nullability\032\251\001\n\006IfElse\0225\n\014if_con"
+  "dition\030\001 \001(\0132\037.substrait.DerivationExpre"
+  "ssion\0222\n\tif_return\030\002 \001(\0132\037.substrait.Der"
+  "ivationExpression\0224\n\013else_return\030\003 \001(\0132\037"
+  ".substrait.DerivationExpression\032\312\001\n\007Unar"
+  "yOp\022D\n\007op_type\030\001 \001(\01623.substrait.Derivat"
+  "ionExpression.UnaryOp.UnaryOpType\022,\n\003arg"
+  "\030\002 \001(\0132\037.substrait.DerivationExpression\""
+  "K\n\013UnaryOpType\022\035\n\031UNARY_OP_TYPE_UNSPECIF"
+  "IED\020\000\022\035\n\031UNARY_OP_TYPE_BOOLEAN_NOT\020\001\032\240\004\n"
+  "\010BinaryOp\022F\n\007op_type\030\001 \001(\01625.substrait.D"
+  "erivationExpression.BinaryOp.BinaryOpTyp"
+  "e\022-\n\004arg1\030\002 \001(\0132\037.substrait.DerivationEx"
+  "pression\022-\n\004arg2\030\003 \001(\0132\037.substrait.Deriv"
+  "ationExpression\"\355\002\n\014BinaryOpType\022\036\n\032BINA"
+  "RY_OP_TYPE_UNSPECIFIED\020\000\022\027\n\023BINARY_OP_TY"
+  "PE_PLUS\020\001\022\030\n\024BINARY_OP_TYPE_MINUS\020\002\022\033\n\027B"
+  "INARY_OP_TYPE_MULTIPLY\020\003\022\031\n\025BINARY_OP_TY"
+  "PE_DIVIDE\020\004\022\026\n\022BINARY_OP_TYPE_MIN\020\005\022\026\n\022B"
+  "INARY_OP_TYPE_MAX\020\006\022\037\n\033BINARY_OP_TYPE_GR"
+  "EATER_THAN\020\007\022\034\n\030BINARY_OP_TYPE_LESS_THAN"
+  "\020\010\022\026\n\022BINARY_OP_TYPE_AND\020\t\022\025\n\021BINARY_OP_"
+  "TYPE_OR\020\n\022\031\n\025BINARY_OP_TYPE_EQUALS\020\013\022\031\n\025"
+  "BINARY_OP_TYPE_COVERS\020\014\032\352\001\n\rReturnProgra"
+  "m\022M\n\013assignments\030\001 \003(\01328.substrait.Deriv"
+  "ationExpression.ReturnProgram.Assignment"
+  "\0229\n\020final_expression\030\002 \001(\0132\037.substrait.D"
+  "erivationExpression\032O\n\nAssignment\022\014\n\004nam"
+  "e\030\001 \001(\t\0223\n\nexpression\030\002 \001(\0132\037.substrait."
+  "DerivationExpressionB\006\n\004kindB+\n\022io.subst"
+  "rait.protoP\001\252\002\022Substrait.Protobufb\006proto"
+  "3"
+  ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2ftype_5fexpressions_2eproto_deps[1] = {
+  &::descriptor_table_substrait_2ftype_2eproto,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2ftype_5fexpressions_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_5fexpressions_2eproto = {
+  false, false, 4081, descriptor_table_protodef_substrait_2ftype_5fexpressions_2eproto, "substrait/type_expressions.proto", 
+  &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, descriptor_table_substrait_2ftype_5fexpressions_2eproto_deps, 1, 14,
+  schemas, file_default_instances, TableStruct_substrait_2ftype_5fexpressions_2eproto::offsets,
+  file_level_metadata_substrait_2ftype_5fexpressions_2eproto, file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto, file_level_service_descriptors_substrait_2ftype_5fexpressions_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter() {
+  return &descriptor_table_substrait_2ftype_5fexpressions_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2ftype_5fexpressions_2eproto(&descriptor_table_substrait_2ftype_5fexpressions_2eproto);
+namespace substrait {
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_UnaryOp_UnaryOpType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ftype_5fexpressions_2eproto);
+  return file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[0];
+}
+bool DerivationExpression_UnaryOp_UnaryOpType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UNARY_OP_TYPE_UNSPECIFIED;
+constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UNARY_OP_TYPE_BOOLEAN_NOT;
+constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UnaryOpType_MIN;
+constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UnaryOpType_MAX;
+constexpr int DerivationExpression_UnaryOp::UnaryOpType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_BinaryOpType_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ftype_5fexpressions_2eproto);
+  return file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[1];
+}
+bool DerivationExpression_BinaryOp_BinaryOpType_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_UNSPECIFIED;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_PLUS;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MINUS;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MULTIPLY;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_DIVIDE;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MIN;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MAX;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_GREATER_THAN;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_LESS_THAN;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_AND;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_OR;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_EQUALS;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_COVERS;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BinaryOpType_MIN;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BinaryOpType_MAX;
+constexpr int DerivationExpression_BinaryOp::BinaryOpType_ARRAYSIZE;
+#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
+
+// ===================================================================
+
+class DerivationExpression_ExpressionFixedChar::_Internal {
+ public:
+  static const ::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedChar* msg);
+};
+
+const ::substrait::DerivationExpression&
+DerivationExpression_ExpressionFixedChar::_Internal::length(const DerivationExpression_ExpressionFixedChar* msg) {
+  return *msg->length_;
+}
+DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionFixedChar)
+}
+DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(const DerivationExpression_ExpressionFixedChar& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_length()) {
+    length_ = new ::substrait::DerivationExpression(*from.length_);
+  } else {
+    length_ = nullptr;
+  }
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionFixedChar)
+}
+
+inline void DerivationExpression_ExpressionFixedChar::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&length_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+}
+
+DerivationExpression_ExpressionFixedChar::~DerivationExpression_ExpressionFixedChar() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionFixedChar)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_ExpressionFixedChar::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete length_;
+}
+
+void DerivationExpression_ExpressionFixedChar::ArenaDtor(void* object) {
+  DerivationExpression_ExpressionFixedChar* _this = reinterpret_cast< DerivationExpression_ExpressionFixedChar* >(object);
+  (void)_this;
+}
+void DerivationExpression_ExpressionFixedChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_ExpressionFixedChar::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_ExpressionFixedChar::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionFixedChar)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
+    delete length_;
+  }
+  length_ = nullptr;
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_ExpressionFixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.DerivationExpression length = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_length(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_ExpressionFixedChar::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionFixedChar)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression length = 1;
+  if (this->_internal_has_length()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::length(this), target, stream);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionFixedChar)
+  return target;
+}
+
+size_t DerivationExpression_ExpressionFixedChar::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionFixedChar)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression length = 1;
+  if (this->_internal_has_length()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *length_);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionFixedChar::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_ExpressionFixedChar::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionFixedChar::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_ExpressionFixedChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_ExpressionFixedChar *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_ExpressionFixedChar &>(from));
+}
+
+
+void DerivationExpression_ExpressionFixedChar::MergeFrom(const DerivationExpression_ExpressionFixedChar& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionFixedChar)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_length()) {
+    _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length());
+  }
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_ExpressionFixedChar::CopyFrom(const DerivationExpression_ExpressionFixedChar& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionFixedChar)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_ExpressionFixedChar::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_ExpressionFixedChar::InternalSwap(DerivationExpression_ExpressionFixedChar* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedChar, nullability_)
+      + sizeof(DerivationExpression_ExpressionFixedChar::nullability_)
+      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedChar, length_)>(
+          reinterpret_cast<char*>(&length_),
+          reinterpret_cast<char*>(&other->length_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionFixedChar::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[0]);
+}
+
+// ===================================================================
+
+class DerivationExpression_ExpressionVarChar::_Internal {
+ public:
+  static const ::substrait::DerivationExpression& length(const DerivationExpression_ExpressionVarChar* msg);
+};
+
+const ::substrait::DerivationExpression&
+DerivationExpression_ExpressionVarChar::_Internal::length(const DerivationExpression_ExpressionVarChar* msg) {
+  return *msg->length_;
+}
+DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionVarChar)
+}
+DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(const DerivationExpression_ExpressionVarChar& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_length()) {
+    length_ = new ::substrait::DerivationExpression(*from.length_);
+  } else {
+    length_ = nullptr;
+  }
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionVarChar)
+}
+
+inline void DerivationExpression_ExpressionVarChar::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&length_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+}
+
+DerivationExpression_ExpressionVarChar::~DerivationExpression_ExpressionVarChar() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionVarChar)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_ExpressionVarChar::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete length_;
+}
+
+void DerivationExpression_ExpressionVarChar::ArenaDtor(void* object) {
+  DerivationExpression_ExpressionVarChar* _this = reinterpret_cast< DerivationExpression_ExpressionVarChar* >(object);
+  (void)_this;
+}
+void DerivationExpression_ExpressionVarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_ExpressionVarChar::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_ExpressionVarChar::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionVarChar)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
+    delete length_;
+  }
+  length_ = nullptr;
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_ExpressionVarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.DerivationExpression length = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_length(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_ExpressionVarChar::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionVarChar)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression length = 1;
+  if (this->_internal_has_length()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::length(this), target, stream);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionVarChar)
+  return target;
+}
+
+size_t DerivationExpression_ExpressionVarChar::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionVarChar)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression length = 1;
+  if (this->_internal_has_length()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *length_);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionVarChar::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_ExpressionVarChar::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionVarChar::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_ExpressionVarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_ExpressionVarChar *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_ExpressionVarChar &>(from));
+}
+
+
+void DerivationExpression_ExpressionVarChar::MergeFrom(const DerivationExpression_ExpressionVarChar& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionVarChar)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_length()) {
+    _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length());
+  }
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_ExpressionVarChar::CopyFrom(const DerivationExpression_ExpressionVarChar& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionVarChar)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_ExpressionVarChar::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_ExpressionVarChar::InternalSwap(DerivationExpression_ExpressionVarChar* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionVarChar, nullability_)
+      + sizeof(DerivationExpression_ExpressionVarChar::nullability_)
+      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionVarChar, length_)>(
+          reinterpret_cast<char*>(&length_),
+          reinterpret_cast<char*>(&other->length_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionVarChar::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[1]);
+}
+
+// ===================================================================
+
+class DerivationExpression_ExpressionFixedBinary::_Internal {
+ public:
+  static const ::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedBinary* msg);
+};
+
+const ::substrait::DerivationExpression&
+DerivationExpression_ExpressionFixedBinary::_Internal::length(const DerivationExpression_ExpressionFixedBinary* msg) {
+  return *msg->length_;
+}
+DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionFixedBinary)
+}
+DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(const DerivationExpression_ExpressionFixedBinary& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_length()) {
+    length_ = new ::substrait::DerivationExpression(*from.length_);
+  } else {
+    length_ = nullptr;
+  }
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionFixedBinary)
+}
+
+inline void DerivationExpression_ExpressionFixedBinary::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&length_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&length_)) + sizeof(nullability_));
+}
+
+DerivationExpression_ExpressionFixedBinary::~DerivationExpression_ExpressionFixedBinary() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionFixedBinary)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_ExpressionFixedBinary::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete length_;
+}
+
+void DerivationExpression_ExpressionFixedBinary::ArenaDtor(void* object) {
+  DerivationExpression_ExpressionFixedBinary* _this = reinterpret_cast< DerivationExpression_ExpressionFixedBinary* >(object);
+  (void)_this;
+}
+void DerivationExpression_ExpressionFixedBinary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_ExpressionFixedBinary::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_ExpressionFixedBinary::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionFixedBinary)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
+    delete length_;
+  }
+  length_ = nullptr;
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_ExpressionFixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.DerivationExpression length = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_length(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_ExpressionFixedBinary::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionFixedBinary)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression length = 1;
+  if (this->_internal_has_length()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::length(this), target, stream);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionFixedBinary)
+  return target;
+}
+
+size_t DerivationExpression_ExpressionFixedBinary::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionFixedBinary)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression length = 1;
+  if (this->_internal_has_length()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *length_);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionFixedBinary::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_ExpressionFixedBinary::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionFixedBinary::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_ExpressionFixedBinary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_ExpressionFixedBinary *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_ExpressionFixedBinary &>(from));
+}
+
+
+void DerivationExpression_ExpressionFixedBinary::MergeFrom(const DerivationExpression_ExpressionFixedBinary& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionFixedBinary)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_length()) {
+    _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length());
+  }
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_ExpressionFixedBinary::CopyFrom(const DerivationExpression_ExpressionFixedBinary& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionFixedBinary)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_ExpressionFixedBinary::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_ExpressionFixedBinary::InternalSwap(DerivationExpression_ExpressionFixedBinary* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedBinary, nullability_)
+      + sizeof(DerivationExpression_ExpressionFixedBinary::nullability_)
+      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedBinary, length_)>(
+          reinterpret_cast<char*>(&length_),
+          reinterpret_cast<char*>(&other->length_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionFixedBinary::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[2]);
+}
+
+// ===================================================================
+
+class DerivationExpression_ExpressionDecimal::_Internal {
+ public:
+  static const ::substrait::DerivationExpression& scale(const DerivationExpression_ExpressionDecimal* msg);
+  static const ::substrait::DerivationExpression& precision(const DerivationExpression_ExpressionDecimal* msg);
+};
+
+const ::substrait::DerivationExpression&
+DerivationExpression_ExpressionDecimal::_Internal::scale(const DerivationExpression_ExpressionDecimal* msg) {
+  return *msg->scale_;
+}
+const ::substrait::DerivationExpression&
+DerivationExpression_ExpressionDecimal::_Internal::precision(const DerivationExpression_ExpressionDecimal* msg) {
+  return *msg->precision_;
+}
+DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionDecimal)
+}
+DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(const DerivationExpression_ExpressionDecimal& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_scale()) {
+    scale_ = new ::substrait::DerivationExpression(*from.scale_);
+  } else {
+    scale_ = nullptr;
+  }
+  if (from._internal_has_precision()) {
+    precision_ = new ::substrait::DerivationExpression(*from.precision_);
+  } else {
+    precision_ = nullptr;
+  }
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionDecimal)
+}
+
+inline void DerivationExpression_ExpressionDecimal::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&scale_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&scale_)) + sizeof(nullability_));
+}
+
+DerivationExpression_ExpressionDecimal::~DerivationExpression_ExpressionDecimal() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionDecimal)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_ExpressionDecimal::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete scale_;
+  if (this != internal_default_instance()) delete precision_;
+}
+
+void DerivationExpression_ExpressionDecimal::ArenaDtor(void* object) {
+  DerivationExpression_ExpressionDecimal* _this = reinterpret_cast< DerivationExpression_ExpressionDecimal* >(object);
+  (void)_this;
+}
+void DerivationExpression_ExpressionDecimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_ExpressionDecimal::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_ExpressionDecimal::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionDecimal)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && scale_ != nullptr) {
+    delete scale_;
+  }
+  scale_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && precision_ != nullptr) {
+    delete precision_;
+  }
+  precision_ = nullptr;
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_ExpressionDecimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.DerivationExpression scale = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_scale(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression precision = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_precision(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_ExpressionDecimal::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionDecimal)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression scale = 1;
+  if (this->_internal_has_scale()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::scale(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression precision = 2;
+  if (this->_internal_has_precision()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::precision(this), target, stream);
+  }
+
+  // uint32 variation_pointer = 3;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 4;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionDecimal)
+  return target;
+}
+
+size_t DerivationExpression_ExpressionDecimal::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionDecimal)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression scale = 1;
+  if (this->_internal_has_scale()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *scale_);
+  }
+
+  // .substrait.DerivationExpression precision = 2;
+  if (this->_internal_has_precision()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *precision_);
+  }
+
+  // uint32 variation_pointer = 3;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 4;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionDecimal::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_ExpressionDecimal::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionDecimal::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_ExpressionDecimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_ExpressionDecimal *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_ExpressionDecimal &>(from));
+}
+
+
+void DerivationExpression_ExpressionDecimal::MergeFrom(const DerivationExpression_ExpressionDecimal& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionDecimal)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_scale()) {
+    _internal_mutable_scale()->::substrait::DerivationExpression::MergeFrom(from._internal_scale());
+  }
+  if (from._internal_has_precision()) {
+    _internal_mutable_precision()->::substrait::DerivationExpression::MergeFrom(from._internal_precision());
+  }
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_ExpressionDecimal::CopyFrom(const DerivationExpression_ExpressionDecimal& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionDecimal)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_ExpressionDecimal::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_ExpressionDecimal::InternalSwap(DerivationExpression_ExpressionDecimal* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionDecimal, nullability_)
+      + sizeof(DerivationExpression_ExpressionDecimal::nullability_)
+      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionDecimal, scale_)>(
+          reinterpret_cast<char*>(&scale_),
+          reinterpret_cast<char*>(&other->scale_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionDecimal::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[3]);
+}
+
+// ===================================================================
+
+class DerivationExpression_ExpressionStruct::_Internal {
+ public:
+};
+
+DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  types_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionStruct)
+}
+DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(const DerivationExpression_ExpressionStruct& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      types_(from.types_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionStruct)
+}
+
+inline void DerivationExpression_ExpressionStruct::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&variation_pointer_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+}
+
+DerivationExpression_ExpressionStruct::~DerivationExpression_ExpressionStruct() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionStruct)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_ExpressionStruct::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void DerivationExpression_ExpressionStruct::ArenaDtor(void* object) {
+  DerivationExpression_ExpressionStruct* _this = reinterpret_cast< DerivationExpression_ExpressionStruct* >(object);
+  (void)_this;
+}
+void DerivationExpression_ExpressionStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_ExpressionStruct::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_ExpressionStruct::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionStruct)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  types_.Clear();
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_ExpressionStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.DerivationExpression types = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_types(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_ExpressionStruct::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionStruct)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.DerivationExpression types = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_types_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_types(i), target, stream);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionStruct)
+  return target;
+}
+
+size_t DerivationExpression_ExpressionStruct::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionStruct)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.DerivationExpression types = 1;
+  total_size += 1UL * this->_internal_types_size();
+  for (const auto& msg : this->types_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionStruct::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_ExpressionStruct::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionStruct::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_ExpressionStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_ExpressionStruct *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_ExpressionStruct &>(from));
+}
+
+
+void DerivationExpression_ExpressionStruct::MergeFrom(const DerivationExpression_ExpressionStruct& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionStruct)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  types_.MergeFrom(from.types_);
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_ExpressionStruct::CopyFrom(const DerivationExpression_ExpressionStruct& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionStruct)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_ExpressionStruct::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_ExpressionStruct::InternalSwap(DerivationExpression_ExpressionStruct* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  types_.InternalSwap(&other->types_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionStruct, nullability_)
+      + sizeof(DerivationExpression_ExpressionStruct::nullability_)
+      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionStruct, variation_pointer_)>(
+          reinterpret_cast<char*>(&variation_pointer_),
+          reinterpret_cast<char*>(&other->variation_pointer_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionStruct::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[4]);
+}
+
+// ===================================================================
+
+class DerivationExpression_ExpressionNamedStruct::_Internal {
+ public:
+  static const ::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression_ExpressionNamedStruct* msg);
+};
+
+const ::substrait::DerivationExpression_ExpressionStruct&
+DerivationExpression_ExpressionNamedStruct::_Internal::struct_(const DerivationExpression_ExpressionNamedStruct* msg) {
+  return *msg->struct__;
+}
+DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  names_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionNamedStruct)
+}
+DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(const DerivationExpression_ExpressionNamedStruct& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      names_(from.names_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_struct_()) {
+    struct__ = new ::substrait::DerivationExpression_ExpressionStruct(*from.struct__);
+  } else {
+    struct__ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionNamedStruct)
+}
+
+inline void DerivationExpression_ExpressionNamedStruct::SharedCtor() {
+struct__ = nullptr;
+}
+
+DerivationExpression_ExpressionNamedStruct::~DerivationExpression_ExpressionNamedStruct() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionNamedStruct)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_ExpressionNamedStruct::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete struct__;
+}
+
+void DerivationExpression_ExpressionNamedStruct::ArenaDtor(void* object) {
+  DerivationExpression_ExpressionNamedStruct* _this = reinterpret_cast< DerivationExpression_ExpressionNamedStruct* >(object);
+  (void)_this;
+}
+void DerivationExpression_ExpressionNamedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_ExpressionNamedStruct::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_ExpressionNamedStruct::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionNamedStruct)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  names_.Clear();
+  if (GetArenaForAllocation() == nullptr && struct__ != nullptr) {
+    delete struct__;
+  }
+  struct__ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_ExpressionNamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated string names = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            auto str = _internal_add_names();
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.ExpressionNamedStruct.names"));
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression.ExpressionStruct struct = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_ExpressionNamedStruct::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionNamedStruct)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string names = 1;
+  for (int i = 0, n = this->_internal_names_size(); i < n; i++) {
+    const auto& s = this->_internal_names(i);
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      s.data(), static_cast<int>(s.length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.DerivationExpression.ExpressionNamedStruct.names");
+    target = stream->WriteString(1, s, target);
+  }
+
+  // .substrait.DerivationExpression.ExpressionStruct struct = 2;
+  if (this->_internal_has_struct_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::struct_(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionNamedStruct)
+  return target;
+}
+
+size_t DerivationExpression_ExpressionNamedStruct::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionNamedStruct)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string names = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size());
+  for (int i = 0, n = names_.size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      names_.Get(i));
+  }
+
+  // .substrait.DerivationExpression.ExpressionStruct struct = 2;
+  if (this->_internal_has_struct_()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *struct__);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionNamedStruct::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_ExpressionNamedStruct::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionNamedStruct::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_ExpressionNamedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_ExpressionNamedStruct *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_ExpressionNamedStruct &>(from));
+}
+
+
+void DerivationExpression_ExpressionNamedStruct::MergeFrom(const DerivationExpression_ExpressionNamedStruct& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionNamedStruct)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  names_.MergeFrom(from.names_);
+  if (from._internal_has_struct_()) {
+    _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_ExpressionNamedStruct::CopyFrom(const DerivationExpression_ExpressionNamedStruct& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionNamedStruct)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_ExpressionNamedStruct::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_ExpressionNamedStruct::InternalSwap(DerivationExpression_ExpressionNamedStruct* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  names_.InternalSwap(&other->names_);
+  swap(struct__, other->struct__);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionNamedStruct::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[5]);
+}
+
+// ===================================================================
+
+class DerivationExpression_ExpressionList::_Internal {
+ public:
+  static const ::substrait::DerivationExpression& type(const DerivationExpression_ExpressionList* msg);
+};
+
+const ::substrait::DerivationExpression&
+DerivationExpression_ExpressionList::_Internal::type(const DerivationExpression_ExpressionList* msg) {
+  return *msg->type_;
+}
+DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionList)
+}
+DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(const DerivationExpression_ExpressionList& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_type()) {
+    type_ = new ::substrait::DerivationExpression(*from.type_);
+  } else {
+    type_ = nullptr;
+  }
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionList)
+}
+
+inline void DerivationExpression_ExpressionList::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&type_)) + sizeof(nullability_));
+}
+
+DerivationExpression_ExpressionList::~DerivationExpression_ExpressionList() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionList)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_ExpressionList::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete type_;
+}
+
+void DerivationExpression_ExpressionList::ArenaDtor(void* object) {
+  DerivationExpression_ExpressionList* _this = reinterpret_cast< DerivationExpression_ExpressionList* >(object);
+  (void)_this;
+}
+void DerivationExpression_ExpressionList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_ExpressionList::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_ExpressionList::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionList)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
+    delete type_;
+  }
+  type_ = nullptr;
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_ExpressionList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.DerivationExpression type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_type(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_ExpressionList::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionList)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression type = 1;
+  if (this->_internal_has_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::type(this), target, stream);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      3, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionList)
+  return target;
+}
+
+size_t DerivationExpression_ExpressionList::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionList)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression type = 1;
+  if (this->_internal_has_type()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *type_);
+  }
+
+  // uint32 variation_pointer = 2;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 3;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionList::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_ExpressionList::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionList::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_ExpressionList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_ExpressionList *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_ExpressionList &>(from));
+}
+
+
+void DerivationExpression_ExpressionList::MergeFrom(const DerivationExpression_ExpressionList& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionList)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_type()) {
+    _internal_mutable_type()->::substrait::DerivationExpression::MergeFrom(from._internal_type());
+  }
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_ExpressionList::CopyFrom(const DerivationExpression_ExpressionList& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionList)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_ExpressionList::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_ExpressionList::InternalSwap(DerivationExpression_ExpressionList* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionList, nullability_)
+      + sizeof(DerivationExpression_ExpressionList::nullability_)
+      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionList, type_)>(
+          reinterpret_cast<char*>(&type_),
+          reinterpret_cast<char*>(&other->type_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionList::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[6]);
+}
+
+// ===================================================================
+
+class DerivationExpression_ExpressionMap::_Internal {
+ public:
+  static const ::substrait::DerivationExpression& key(const DerivationExpression_ExpressionMap* msg);
+  static const ::substrait::DerivationExpression& value(const DerivationExpression_ExpressionMap* msg);
+};
+
+const ::substrait::DerivationExpression&
+DerivationExpression_ExpressionMap::_Internal::key(const DerivationExpression_ExpressionMap* msg) {
+  return *msg->key_;
+}
+const ::substrait::DerivationExpression&
+DerivationExpression_ExpressionMap::_Internal::value(const DerivationExpression_ExpressionMap* msg) {
+  return *msg->value_;
+}
+DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionMap)
+}
+DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(const DerivationExpression_ExpressionMap& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_key()) {
+    key_ = new ::substrait::DerivationExpression(*from.key_);
+  } else {
+    key_ = nullptr;
+  }
+  if (from._internal_has_value()) {
+    value_ = new ::substrait::DerivationExpression(*from.value_);
+  } else {
+    value_ = nullptr;
+  }
+  ::memcpy(&variation_pointer_, &from.variation_pointer_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionMap)
+}
+
+inline void DerivationExpression_ExpressionMap::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&key_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&nullability_) -
+    reinterpret_cast<char*>(&key_)) + sizeof(nullability_));
+}
+
+DerivationExpression_ExpressionMap::~DerivationExpression_ExpressionMap() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionMap)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_ExpressionMap::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete key_;
+  if (this != internal_default_instance()) delete value_;
+}
+
+void DerivationExpression_ExpressionMap::ArenaDtor(void* object) {
+  DerivationExpression_ExpressionMap* _this = reinterpret_cast< DerivationExpression_ExpressionMap* >(object);
+  (void)_this;
+}
+void DerivationExpression_ExpressionMap::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_ExpressionMap::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_ExpressionMap::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionMap)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && key_ != nullptr) {
+    delete key_;
+  }
+  key_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && value_ != nullptr) {
+    delete value_;
+  }
+  value_ = nullptr;
+  ::memset(&variation_pointer_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nullability_) -
+      reinterpret_cast<char*>(&variation_pointer_)) + sizeof(nullability_));
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_ExpressionMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.DerivationExpression key = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_value(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 variation_pointer = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Nullability nullability = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_ExpressionMap::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionMap)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression key = 1;
+  if (this->_internal_has_key()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::key(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression value = 2;
+  if (this->_internal_has_value()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::value(this), target, stream);
+  }
+
+  // uint32 variation_pointer = 3;
+  if (this->_internal_variation_pointer() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target);
+  }
+
+  // .substrait.Type.Nullability nullability = 4;
+  if (this->_internal_nullability() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      4, this->_internal_nullability(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionMap)
+  return target;
+}
+
+size_t DerivationExpression_ExpressionMap::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionMap)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression key = 1;
+  if (this->_internal_has_key()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *key_);
+  }
+
+  // .substrait.DerivationExpression value = 2;
+  if (this->_internal_has_value()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *value_);
+  }
+
+  // uint32 variation_pointer = 3;
+  if (this->_internal_variation_pointer() != 0) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer());
+  }
+
+  // .substrait.Type.Nullability nullability = 4;
+  if (this->_internal_nullability() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionMap::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_ExpressionMap::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionMap::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_ExpressionMap::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_ExpressionMap *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_ExpressionMap &>(from));
+}
+
+
+void DerivationExpression_ExpressionMap::MergeFrom(const DerivationExpression_ExpressionMap& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionMap)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_key()) {
+    _internal_mutable_key()->::substrait::DerivationExpression::MergeFrom(from._internal_key());
+  }
+  if (from._internal_has_value()) {
+    _internal_mutable_value()->::substrait::DerivationExpression::MergeFrom(from._internal_value());
+  }
+  if (from._internal_variation_pointer() != 0) {
+    _internal_set_variation_pointer(from._internal_variation_pointer());
+  }
+  if (from._internal_nullability() != 0) {
+    _internal_set_nullability(from._internal_nullability());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_ExpressionMap::CopyFrom(const DerivationExpression_ExpressionMap& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionMap)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_ExpressionMap::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_ExpressionMap::InternalSwap(DerivationExpression_ExpressionMap* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionMap, nullability_)
+      + sizeof(DerivationExpression_ExpressionMap::nullability_)
+      - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionMap, key_)>(
+          reinterpret_cast<char*>(&key_),
+          reinterpret_cast<char*>(&other->key_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionMap::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[7]);
+}
+
+// ===================================================================
+
+class DerivationExpression_IfElse::_Internal {
+ public:
+  static const ::substrait::DerivationExpression& if_condition(const DerivationExpression_IfElse* msg);
+  static const ::substrait::DerivationExpression& if_return(const DerivationExpression_IfElse* msg);
+  static const ::substrait::DerivationExpression& else_return(const DerivationExpression_IfElse* msg);
+};
+
+const ::substrait::DerivationExpression&
+DerivationExpression_IfElse::_Internal::if_condition(const DerivationExpression_IfElse* msg) {
+  return *msg->if_condition_;
+}
+const ::substrait::DerivationExpression&
+DerivationExpression_IfElse::_Internal::if_return(const DerivationExpression_IfElse* msg) {
+  return *msg->if_return_;
+}
+const ::substrait::DerivationExpression&
+DerivationExpression_IfElse::_Internal::else_return(const DerivationExpression_IfElse* msg) {
+  return *msg->else_return_;
+}
+DerivationExpression_IfElse::DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.IfElse)
+}
+DerivationExpression_IfElse::DerivationExpression_IfElse(const DerivationExpression_IfElse& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_if_condition()) {
+    if_condition_ = new ::substrait::DerivationExpression(*from.if_condition_);
+  } else {
+    if_condition_ = nullptr;
+  }
+  if (from._internal_has_if_return()) {
+    if_return_ = new ::substrait::DerivationExpression(*from.if_return_);
+  } else {
+    if_return_ = nullptr;
+  }
+  if (from._internal_has_else_return()) {
+    else_return_ = new ::substrait::DerivationExpression(*from.else_return_);
+  } else {
+    else_return_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.IfElse)
+}
+
+inline void DerivationExpression_IfElse::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&if_condition_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&else_return_) -
+    reinterpret_cast<char*>(&if_condition_)) + sizeof(else_return_));
+}
+
+DerivationExpression_IfElse::~DerivationExpression_IfElse() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.IfElse)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_IfElse::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete if_condition_;
+  if (this != internal_default_instance()) delete if_return_;
+  if (this != internal_default_instance()) delete else_return_;
+}
+
+void DerivationExpression_IfElse::ArenaDtor(void* object) {
+  DerivationExpression_IfElse* _this = reinterpret_cast< DerivationExpression_IfElse* >(object);
+  (void)_this;
+}
+void DerivationExpression_IfElse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_IfElse::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_IfElse::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.IfElse)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && if_condition_ != nullptr) {
+    delete if_condition_;
+  }
+  if_condition_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && if_return_ != nullptr) {
+    delete if_return_;
+  }
+  if_return_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && else_return_ != nullptr) {
+    delete else_return_;
+  }
+  else_return_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_IfElse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.DerivationExpression if_condition = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_if_condition(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression if_return = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_if_return(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression else_return = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_else_return(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_IfElse::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.IfElse)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression if_condition = 1;
+  if (this->_internal_has_if_condition()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::if_condition(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression if_return = 2;
+  if (this->_internal_has_if_return()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::if_return(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression else_return = 3;
+  if (this->_internal_has_else_return()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::else_return(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.IfElse)
+  return target;
+}
+
+size_t DerivationExpression_IfElse::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.IfElse)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression if_condition = 1;
+  if (this->_internal_has_if_condition()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *if_condition_);
+  }
+
+  // .substrait.DerivationExpression if_return = 2;
+  if (this->_internal_has_if_return()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *if_return_);
+  }
+
+  // .substrait.DerivationExpression else_return = 3;
+  if (this->_internal_has_else_return()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *else_return_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_IfElse::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_IfElse::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_IfElse::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_IfElse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_IfElse *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_IfElse &>(from));
+}
+
+
+void DerivationExpression_IfElse::MergeFrom(const DerivationExpression_IfElse& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.IfElse)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_if_condition()) {
+    _internal_mutable_if_condition()->::substrait::DerivationExpression::MergeFrom(from._internal_if_condition());
+  }
+  if (from._internal_has_if_return()) {
+    _internal_mutable_if_return()->::substrait::DerivationExpression::MergeFrom(from._internal_if_return());
+  }
+  if (from._internal_has_else_return()) {
+    _internal_mutable_else_return()->::substrait::DerivationExpression::MergeFrom(from._internal_else_return());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_IfElse::CopyFrom(const DerivationExpression_IfElse& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.IfElse)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_IfElse::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_IfElse::InternalSwap(DerivationExpression_IfElse* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DerivationExpression_IfElse, else_return_)
+      + sizeof(DerivationExpression_IfElse::else_return_)
+      - PROTOBUF_FIELD_OFFSET(DerivationExpression_IfElse, if_condition_)>(
+          reinterpret_cast<char*>(&if_condition_),
+          reinterpret_cast<char*>(&other->if_condition_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_IfElse::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[8]);
+}
+
+// ===================================================================
+
+class DerivationExpression_UnaryOp::_Internal {
+ public:
+  static const ::substrait::DerivationExpression& arg(const DerivationExpression_UnaryOp* msg);
+};
+
+const ::substrait::DerivationExpression&
+DerivationExpression_UnaryOp::_Internal::arg(const DerivationExpression_UnaryOp* msg) {
+  return *msg->arg_;
+}
+DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.UnaryOp)
+}
+DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(const DerivationExpression_UnaryOp& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_arg()) {
+    arg_ = new ::substrait::DerivationExpression(*from.arg_);
+  } else {
+    arg_ = nullptr;
+  }
+  op_type_ = from.op_type_;
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.UnaryOp)
+}
+
+inline void DerivationExpression_UnaryOp::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&arg_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&op_type_) -
+    reinterpret_cast<char*>(&arg_)) + sizeof(op_type_));
+}
+
+DerivationExpression_UnaryOp::~DerivationExpression_UnaryOp() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.UnaryOp)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_UnaryOp::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete arg_;
+}
+
+void DerivationExpression_UnaryOp::ArenaDtor(void* object) {
+  DerivationExpression_UnaryOp* _this = reinterpret_cast< DerivationExpression_UnaryOp* >(object);
+  (void)_this;
+}
+void DerivationExpression_UnaryOp::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_UnaryOp::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_UnaryOp::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.UnaryOp)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && arg_ != nullptr) {
+    delete arg_;
+  }
+  arg_ = nullptr;
+  op_type_ = 0;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_UnaryOp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_op_type(static_cast<::substrait::DerivationExpression_UnaryOp_UnaryOpType>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression arg = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_arg(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_UnaryOp::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.UnaryOp)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1;
+  if (this->_internal_op_type() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_op_type(), target);
+  }
+
+  // .substrait.DerivationExpression arg = 2;
+  if (this->_internal_has_arg()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::arg(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.UnaryOp)
+  return target;
+}
+
+size_t DerivationExpression_UnaryOp::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.UnaryOp)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression arg = 2;
+  if (this->_internal_has_arg()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *arg_);
+  }
+
+  // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1;
+  if (this->_internal_op_type() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op_type());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_UnaryOp::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_UnaryOp::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_UnaryOp::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_UnaryOp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_UnaryOp *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_UnaryOp &>(from));
+}
+
+
+void DerivationExpression_UnaryOp::MergeFrom(const DerivationExpression_UnaryOp& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.UnaryOp)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_arg()) {
+    _internal_mutable_arg()->::substrait::DerivationExpression::MergeFrom(from._internal_arg());
+  }
+  if (from._internal_op_type() != 0) {
+    _internal_set_op_type(from._internal_op_type());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_UnaryOp::CopyFrom(const DerivationExpression_UnaryOp& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.UnaryOp)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_UnaryOp::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_UnaryOp::InternalSwap(DerivationExpression_UnaryOp* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DerivationExpression_UnaryOp, op_type_)
+      + sizeof(DerivationExpression_UnaryOp::op_type_)
+      - PROTOBUF_FIELD_OFFSET(DerivationExpression_UnaryOp, arg_)>(
+          reinterpret_cast<char*>(&arg_),
+          reinterpret_cast<char*>(&other->arg_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_UnaryOp::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[9]);
+}
+
+// ===================================================================
+
+class DerivationExpression_BinaryOp::_Internal {
+ public:
+  static const ::substrait::DerivationExpression& arg1(const DerivationExpression_BinaryOp* msg);
+  static const ::substrait::DerivationExpression& arg2(const DerivationExpression_BinaryOp* msg);
+};
+
+const ::substrait::DerivationExpression&
+DerivationExpression_BinaryOp::_Internal::arg1(const DerivationExpression_BinaryOp* msg) {
+  return *msg->arg1_;
+}
+const ::substrait::DerivationExpression&
+DerivationExpression_BinaryOp::_Internal::arg2(const DerivationExpression_BinaryOp* msg) {
+  return *msg->arg2_;
+}
+DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.BinaryOp)
+}
+DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(const DerivationExpression_BinaryOp& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_arg1()) {
+    arg1_ = new ::substrait::DerivationExpression(*from.arg1_);
+  } else {
+    arg1_ = nullptr;
+  }
+  if (from._internal_has_arg2()) {
+    arg2_ = new ::substrait::DerivationExpression(*from.arg2_);
+  } else {
+    arg2_ = nullptr;
+  }
+  op_type_ = from.op_type_;
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.BinaryOp)
+}
+
+inline void DerivationExpression_BinaryOp::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&arg1_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&op_type_) -
+    reinterpret_cast<char*>(&arg1_)) + sizeof(op_type_));
+}
+
+DerivationExpression_BinaryOp::~DerivationExpression_BinaryOp() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.BinaryOp)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_BinaryOp::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete arg1_;
+  if (this != internal_default_instance()) delete arg2_;
+}
+
+void DerivationExpression_BinaryOp::ArenaDtor(void* object) {
+  DerivationExpression_BinaryOp* _this = reinterpret_cast< DerivationExpression_BinaryOp* >(object);
+  (void)_this;
+}
+void DerivationExpression_BinaryOp::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_BinaryOp::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_BinaryOp::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.BinaryOp)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaForAllocation() == nullptr && arg1_ != nullptr) {
+    delete arg1_;
+  }
+  arg1_ = nullptr;
+  if (GetArenaForAllocation() == nullptr && arg2_ != nullptr) {
+    delete arg2_;
+  }
+  arg2_ = nullptr;
+  op_type_ = 0;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_BinaryOp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+          _internal_set_op_type(static_cast<::substrait::DerivationExpression_BinaryOp_BinaryOpType>(val));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression arg1 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_arg1(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression arg2 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_arg2(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_BinaryOp::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.BinaryOp)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1;
+  if (this->_internal_op_type() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      1, this->_internal_op_type(), target);
+  }
+
+  // .substrait.DerivationExpression arg1 = 2;
+  if (this->_internal_has_arg1()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::arg1(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression arg2 = 3;
+  if (this->_internal_has_arg2()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::arg2(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.BinaryOp)
+  return target;
+}
+
+size_t DerivationExpression_BinaryOp::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.BinaryOp)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .substrait.DerivationExpression arg1 = 2;
+  if (this->_internal_has_arg1()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *arg1_);
+  }
+
+  // .substrait.DerivationExpression arg2 = 3;
+  if (this->_internal_has_arg2()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *arg2_);
+  }
+
+  // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1;
+  if (this->_internal_op_type() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op_type());
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_BinaryOp::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_BinaryOp::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_BinaryOp::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_BinaryOp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_BinaryOp *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_BinaryOp &>(from));
+}
+
+
+void DerivationExpression_BinaryOp::MergeFrom(const DerivationExpression_BinaryOp& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.BinaryOp)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from._internal_has_arg1()) {
+    _internal_mutable_arg1()->::substrait::DerivationExpression::MergeFrom(from._internal_arg1());
+  }
+  if (from._internal_has_arg2()) {
+    _internal_mutable_arg2()->::substrait::DerivationExpression::MergeFrom(from._internal_arg2());
+  }
+  if (from._internal_op_type() != 0) {
+    _internal_set_op_type(from._internal_op_type());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_BinaryOp::CopyFrom(const DerivationExpression_BinaryOp& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.BinaryOp)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_BinaryOp::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_BinaryOp::InternalSwap(DerivationExpression_BinaryOp* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(DerivationExpression_BinaryOp, op_type_)
+      + sizeof(DerivationExpression_BinaryOp::op_type_)
+      - PROTOBUF_FIELD_OFFSET(DerivationExpression_BinaryOp, arg1_)>(
+          reinterpret_cast<char*>(&arg1_),
+          reinterpret_cast<char*>(&other->arg1_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_BinaryOp::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[10]);
+}
+
+// ===================================================================
+
+class DerivationExpression_ReturnProgram_Assignment::_Internal {
+ public:
+  static const ::substrait::DerivationExpression& expression(const DerivationExpression_ReturnProgram_Assignment* msg);
+};
+
+const ::substrait::DerivationExpression&
+DerivationExpression_ReturnProgram_Assignment::_Internal::expression(const DerivationExpression_ReturnProgram_Assignment* msg) {
+  return *msg->expression_;
+}
+DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ReturnProgram.Assignment)
+}
+DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(const DerivationExpression_ReturnProgram_Assignment& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (!from._internal_name().empty()) {
+    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
+      GetArenaForAllocation());
+  }
+  if (from._internal_has_expression()) {
+    expression_ = new ::substrait::DerivationExpression(*from.expression_);
+  } else {
+    expression_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ReturnProgram.Assignment)
+}
+
+inline void DerivationExpression_ReturnProgram_Assignment::SharedCtor() {
+name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+expression_ = nullptr;
+}
+
+DerivationExpression_ReturnProgram_Assignment::~DerivationExpression_ReturnProgram_Assignment() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ReturnProgram.Assignment)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_ReturnProgram_Assignment::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (this != internal_default_instance()) delete expression_;
+}
+
+void DerivationExpression_ReturnProgram_Assignment::ArenaDtor(void* object) {
+  DerivationExpression_ReturnProgram_Assignment* _this = reinterpret_cast< DerivationExpression_ReturnProgram_Assignment* >(object);
+  (void)_this;
+}
+void DerivationExpression_ReturnProgram_Assignment::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_ReturnProgram_Assignment::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_ReturnProgram_Assignment::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ReturnProgram.Assignment)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  name_.ClearToEmpty();
+  if (GetArenaForAllocation() == nullptr && expression_ != nullptr) {
+    delete expression_;
+  }
+  expression_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_ReturnProgram_Assignment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // string name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_name();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.ReturnProgram.Assignment.name"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression expression = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_ReturnProgram_Assignment::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ReturnProgram.Assignment)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string name = 1;
+  if (!this->_internal_name().empty()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.DerivationExpression.ReturnProgram.Assignment.name");
+    target = stream->WriteStringMaybeAliased(
+        1, this->_internal_name(), target);
+  }
+
+  // .substrait.DerivationExpression expression = 2;
+  if (this->_internal_has_expression()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::expression(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ReturnProgram.Assignment)
+  return target;
+}
+
+size_t DerivationExpression_ReturnProgram_Assignment::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ReturnProgram.Assignment)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string name = 1;
+  if (!this->_internal_name().empty()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->_internal_name());
+  }
+
+  // .substrait.DerivationExpression expression = 2;
+  if (this->_internal_has_expression()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *expression_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ReturnProgram_Assignment::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_ReturnProgram_Assignment::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ReturnProgram_Assignment::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_ReturnProgram_Assignment::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_ReturnProgram_Assignment *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_ReturnProgram_Assignment &>(from));
+}
+
+
+void DerivationExpression_ReturnProgram_Assignment::MergeFrom(const DerivationExpression_ReturnProgram_Assignment& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ReturnProgram.Assignment)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (!from._internal_name().empty()) {
+    _internal_set_name(from._internal_name());
+  }
+  if (from._internal_has_expression()) {
+    _internal_mutable_expression()->::substrait::DerivationExpression::MergeFrom(from._internal_expression());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_ReturnProgram_Assignment::CopyFrom(const DerivationExpression_ReturnProgram_Assignment& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ReturnProgram.Assignment)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_ReturnProgram_Assignment::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_ReturnProgram_Assignment::InternalSwap(DerivationExpression_ReturnProgram_Assignment* other) {
+  using std::swap;
+  auto* lhs_arena = GetArenaForAllocation();
+  auto* rhs_arena = other->GetArenaForAllocation();
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      &name_, lhs_arena,
+      &other->name_, rhs_arena
+  );
+  swap(expression_, other->expression_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ReturnProgram_Assignment::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[11]);
+}
+
+// ===================================================================
+
+class DerivationExpression_ReturnProgram::_Internal {
+ public:
+  static const ::substrait::DerivationExpression& final_expression(const DerivationExpression_ReturnProgram* msg);
+};
+
+const ::substrait::DerivationExpression&
+DerivationExpression_ReturnProgram::_Internal::final_expression(const DerivationExpression_ReturnProgram* msg) {
+  return *msg->final_expression_;
+}
+DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+  assignments_(arena) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ReturnProgram)
+}
+DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(const DerivationExpression_ReturnProgram& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      assignments_(from.assignments_) {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  if (from._internal_has_final_expression()) {
+    final_expression_ = new ::substrait::DerivationExpression(*from.final_expression_);
+  } else {
+    final_expression_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ReturnProgram)
+}
+
+inline void DerivationExpression_ReturnProgram::SharedCtor() {
+final_expression_ = nullptr;
+}
+
+DerivationExpression_ReturnProgram::~DerivationExpression_ReturnProgram() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ReturnProgram)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression_ReturnProgram::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (this != internal_default_instance()) delete final_expression_;
+}
+
+void DerivationExpression_ReturnProgram::ArenaDtor(void* object) {
+  DerivationExpression_ReturnProgram* _this = reinterpret_cast< DerivationExpression_ReturnProgram* >(object);
+  (void)_this;
+}
+void DerivationExpression_ReturnProgram::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression_ReturnProgram::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression_ReturnProgram::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ReturnProgram)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  assignments_.Clear();
+  if (GetArenaForAllocation() == nullptr && final_expression_ != nullptr) {
+    delete final_expression_;
+  }
+  final_expression_ = nullptr;
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression_ReturnProgram::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_assignments(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression final_expression = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_final_expression(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression_ReturnProgram::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ReturnProgram)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_assignments_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_assignments(i), target, stream);
+  }
+
+  // .substrait.DerivationExpression final_expression = 2;
+  if (this->_internal_has_final_expression()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::final_expression(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ReturnProgram)
+  return target;
+}
+
+size_t DerivationExpression_ReturnProgram::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ReturnProgram)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1;
+  total_size += 1UL * this->_internal_assignments_size();
+  for (const auto& msg : this->assignments_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // .substrait.DerivationExpression final_expression = 2;
+  if (this->_internal_has_final_expression()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *final_expression_);
+  }
+
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ReturnProgram::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression_ReturnProgram::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ReturnProgram::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression_ReturnProgram::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression_ReturnProgram *>(to)->MergeFrom(
+      static_cast<const DerivationExpression_ReturnProgram &>(from));
+}
+
+
+void DerivationExpression_ReturnProgram::MergeFrom(const DerivationExpression_ReturnProgram& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ReturnProgram)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  assignments_.MergeFrom(from.assignments_);
+  if (from._internal_has_final_expression()) {
+    _internal_mutable_final_expression()->::substrait::DerivationExpression::MergeFrom(from._internal_final_expression());
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression_ReturnProgram::CopyFrom(const DerivationExpression_ReturnProgram& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ReturnProgram)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression_ReturnProgram::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression_ReturnProgram::InternalSwap(DerivationExpression_ReturnProgram* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  assignments_.InternalSwap(&other->assignments_);
+  swap(final_expression_, other->final_expression_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ReturnProgram::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[12]);
+}
+
+// ===================================================================
+
+class DerivationExpression::_Internal {
+ public:
+  static const ::substrait::Type_Boolean& bool_(const DerivationExpression* msg);
+  static const ::substrait::Type_I8& i8(const DerivationExpression* msg);
+  static const ::substrait::Type_I16& i16(const DerivationExpression* msg);
+  static const ::substrait::Type_I32& i32(const DerivationExpression* msg);
+  static const ::substrait::Type_I64& i64(const DerivationExpression* msg);
+  static const ::substrait::Type_FP32& fp32(const DerivationExpression* msg);
+  static const ::substrait::Type_FP64& fp64(const DerivationExpression* msg);
+  static const ::substrait::Type_String& string(const DerivationExpression* msg);
+  static const ::substrait::Type_Binary& binary(const DerivationExpression* msg);
+  static const ::substrait::Type_Timestamp& timestamp(const DerivationExpression* msg);
+  static const ::substrait::Type_Date& date(const DerivationExpression* msg);
+  static const ::substrait::Type_Time& time(const DerivationExpression* msg);
+  static const ::substrait::Type_IntervalYear& interval_year(const DerivationExpression* msg);
+  static const ::substrait::Type_IntervalDay& interval_day(const DerivationExpression* msg);
+  static const ::substrait::Type_TimestampTZ& timestamp_tz(const DerivationExpression* msg);
+  static const ::substrait::Type_UUID& uuid(const DerivationExpression* msg);
+  static const ::substrait::DerivationExpression_ExpressionFixedChar& fixed_char(const DerivationExpression* msg);
+  static const ::substrait::DerivationExpression_ExpressionVarChar& varchar(const DerivationExpression* msg);
+  static const ::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary(const DerivationExpression* msg);
+  static const ::substrait::DerivationExpression_ExpressionDecimal& decimal(const DerivationExpression* msg);
+  static const ::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression* msg);
+  static const ::substrait::DerivationExpression_ExpressionList& list(const DerivationExpression* msg);
+  static const ::substrait::DerivationExpression_ExpressionMap& map(const DerivationExpression* msg);
+  static const ::substrait::DerivationExpression_UnaryOp& unary_op(const DerivationExpression* msg);
+  static const ::substrait::DerivationExpression_BinaryOp& binary_op(const DerivationExpression* msg);
+  static const ::substrait::DerivationExpression_IfElse& if_else(const DerivationExpression* msg);
+  static const ::substrait::DerivationExpression_ReturnProgram& return_program(const DerivationExpression* msg);
+};
+
+const ::substrait::Type_Boolean&
+DerivationExpression::_Internal::bool_(const DerivationExpression* msg) {
+  return *msg->kind_.bool__;
+}
+const ::substrait::Type_I8&
+DerivationExpression::_Internal::i8(const DerivationExpression* msg) {
+  return *msg->kind_.i8_;
+}
+const ::substrait::Type_I16&
+DerivationExpression::_Internal::i16(const DerivationExpression* msg) {
+  return *msg->kind_.i16_;
+}
+const ::substrait::Type_I32&
+DerivationExpression::_Internal::i32(const DerivationExpression* msg) {
+  return *msg->kind_.i32_;
+}
+const ::substrait::Type_I64&
+DerivationExpression::_Internal::i64(const DerivationExpression* msg) {
+  return *msg->kind_.i64_;
+}
+const ::substrait::Type_FP32&
+DerivationExpression::_Internal::fp32(const DerivationExpression* msg) {
+  return *msg->kind_.fp32_;
+}
+const ::substrait::Type_FP64&
+DerivationExpression::_Internal::fp64(const DerivationExpression* msg) {
+  return *msg->kind_.fp64_;
+}
+const ::substrait::Type_String&
+DerivationExpression::_Internal::string(const DerivationExpression* msg) {
+  return *msg->kind_.string_;
+}
+const ::substrait::Type_Binary&
+DerivationExpression::_Internal::binary(const DerivationExpression* msg) {
+  return *msg->kind_.binary_;
+}
+const ::substrait::Type_Timestamp&
+DerivationExpression::_Internal::timestamp(const DerivationExpression* msg) {
+  return *msg->kind_.timestamp_;
+}
+const ::substrait::Type_Date&
+DerivationExpression::_Internal::date(const DerivationExpression* msg) {
+  return *msg->kind_.date_;
+}
+const ::substrait::Type_Time&
+DerivationExpression::_Internal::time(const DerivationExpression* msg) {
+  return *msg->kind_.time_;
+}
+const ::substrait::Type_IntervalYear&
+DerivationExpression::_Internal::interval_year(const DerivationExpression* msg) {
+  return *msg->kind_.interval_year_;
+}
+const ::substrait::Type_IntervalDay&
+DerivationExpression::_Internal::interval_day(const DerivationExpression* msg) {
+  return *msg->kind_.interval_day_;
+}
+const ::substrait::Type_TimestampTZ&
+DerivationExpression::_Internal::timestamp_tz(const DerivationExpression* msg) {
+  return *msg->kind_.timestamp_tz_;
+}
+const ::substrait::Type_UUID&
+DerivationExpression::_Internal::uuid(const DerivationExpression* msg) {
+  return *msg->kind_.uuid_;
+}
+const ::substrait::DerivationExpression_ExpressionFixedChar&
+DerivationExpression::_Internal::fixed_char(const DerivationExpression* msg) {
+  return *msg->kind_.fixed_char_;
+}
+const ::substrait::DerivationExpression_ExpressionVarChar&
+DerivationExpression::_Internal::varchar(const DerivationExpression* msg) {
+  return *msg->kind_.varchar_;
+}
+const ::substrait::DerivationExpression_ExpressionFixedBinary&
+DerivationExpression::_Internal::fixed_binary(const DerivationExpression* msg) {
+  return *msg->kind_.fixed_binary_;
+}
+const ::substrait::DerivationExpression_ExpressionDecimal&
+DerivationExpression::_Internal::decimal(const DerivationExpression* msg) {
+  return *msg->kind_.decimal_;
+}
+const ::substrait::DerivationExpression_ExpressionStruct&
+DerivationExpression::_Internal::struct_(const DerivationExpression* msg) {
+  return *msg->kind_.struct__;
+}
+const ::substrait::DerivationExpression_ExpressionList&
+DerivationExpression::_Internal::list(const DerivationExpression* msg) {
+  return *msg->kind_.list_;
+}
+const ::substrait::DerivationExpression_ExpressionMap&
+DerivationExpression::_Internal::map(const DerivationExpression* msg) {
+  return *msg->kind_.map_;
+}
+const ::substrait::DerivationExpression_UnaryOp&
+DerivationExpression::_Internal::unary_op(const DerivationExpression* msg) {
+  return *msg->kind_.unary_op_;
+}
+const ::substrait::DerivationExpression_BinaryOp&
+DerivationExpression::_Internal::binary_op(const DerivationExpression* msg) {
+  return *msg->kind_.binary_op_;
+}
+const ::substrait::DerivationExpression_IfElse&
+DerivationExpression::_Internal::if_else(const DerivationExpression* msg) {
+  return *msg->kind_.if_else_;
+}
+const ::substrait::DerivationExpression_ReturnProgram&
+DerivationExpression::_Internal::return_program(const DerivationExpression* msg) {
+  return *msg->kind_.return_program_;
+}
+void DerivationExpression::set_allocated_bool_(::substrait::Type_Boolean* bool_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (bool_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bool_));
+    if (message_arena != submessage_arena) {
+      bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, bool_, submessage_arena);
+    }
+    set_has_bool_();
+    kind_.bool__ = bool_;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.bool)
+}
+void DerivationExpression::clear_bool_() {
+  if (_internal_has_bool_()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.bool__;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_i8(::substrait::Type_I8* i8) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (i8) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i8));
+    if (message_arena != submessage_arena) {
+      i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, i8, submessage_arena);
+    }
+    set_has_i8();
+    kind_.i8_ = i8;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i8)
+}
+void DerivationExpression::clear_i8() {
+  if (_internal_has_i8()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.i8_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_i16(::substrait::Type_I16* i16) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (i16) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i16));
+    if (message_arena != submessage_arena) {
+      i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, i16, submessage_arena);
+    }
+    set_has_i16();
+    kind_.i16_ = i16;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i16)
+}
+void DerivationExpression::clear_i16() {
+  if (_internal_has_i16()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.i16_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_i32(::substrait::Type_I32* i32) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (i32) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i32));
+    if (message_arena != submessage_arena) {
+      i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, i32, submessage_arena);
+    }
+    set_has_i32();
+    kind_.i32_ = i32;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i32)
+}
+void DerivationExpression::clear_i32() {
+  if (_internal_has_i32()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.i32_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_i64(::substrait::Type_I64* i64) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (i64) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i64));
+    if (message_arena != submessage_arena) {
+      i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, i64, submessage_arena);
+    }
+    set_has_i64();
+    kind_.i64_ = i64;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i64)
+}
+void DerivationExpression::clear_i64() {
+  if (_internal_has_i64()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.i64_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_fp32(::substrait::Type_FP32* fp32) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (fp32) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp32));
+    if (message_arena != submessage_arena) {
+      fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fp32, submessage_arena);
+    }
+    set_has_fp32();
+    kind_.fp32_ = fp32;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fp32)
+}
+void DerivationExpression::clear_fp32() {
+  if (_internal_has_fp32()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.fp32_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_fp64(::substrait::Type_FP64* fp64) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (fp64) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp64));
+    if (message_arena != submessage_arena) {
+      fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fp64, submessage_arena);
+    }
+    set_has_fp64();
+    kind_.fp64_ = fp64;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fp64)
+}
+void DerivationExpression::clear_fp64() {
+  if (_internal_has_fp64()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.fp64_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_string(::substrait::Type_String* string) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (string) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(string));
+    if (message_arena != submessage_arena) {
+      string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, string, submessage_arena);
+    }
+    set_has_string();
+    kind_.string_ = string;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.string)
+}
+void DerivationExpression::clear_string() {
+  if (_internal_has_string()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.string_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_binary(::substrait::Type_Binary* binary) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (binary) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(binary));
+    if (message_arena != submessage_arena) {
+      binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, binary, submessage_arena);
+    }
+    set_has_binary();
+    kind_.binary_ = binary;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.binary)
+}
+void DerivationExpression::clear_binary() {
+  if (_internal_has_binary()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.binary_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (timestamp) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp));
+    if (message_arena != submessage_arena) {
+      timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    set_has_timestamp();
+    kind_.timestamp_ = timestamp;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.timestamp)
+}
+void DerivationExpression::clear_timestamp() {
+  if (_internal_has_timestamp()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.timestamp_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_date(::substrait::Type_Date* date) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (date) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(date));
+    if (message_arena != submessage_arena) {
+      date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, date, submessage_arena);
+    }
+    set_has_date();
+    kind_.date_ = date;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.date)
+}
+void DerivationExpression::clear_date() {
+  if (_internal_has_date()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.date_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_time(::substrait::Type_Time* time) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (time) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(time));
+    if (message_arena != submessage_arena) {
+      time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, time, submessage_arena);
+    }
+    set_has_time();
+    kind_.time_ = time;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.time)
+}
+void DerivationExpression::clear_time() {
+  if (_internal_has_time()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.time_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (interval_year) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_year));
+    if (message_arena != submessage_arena) {
+      interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, interval_year, submessage_arena);
+    }
+    set_has_interval_year();
+    kind_.interval_year_ = interval_year;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.interval_year)
+}
+void DerivationExpression::clear_interval_year() {
+  if (_internal_has_interval_year()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.interval_year_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (interval_day) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_day));
+    if (message_arena != submessage_arena) {
+      interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, interval_day, submessage_arena);
+    }
+    set_has_interval_day();
+    kind_.interval_day_ = interval_day;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.interval_day)
+}
+void DerivationExpression::clear_interval_day() {
+  if (_internal_has_interval_day()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.interval_day_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (timestamp_tz) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_tz));
+    if (message_arena != submessage_arena) {
+      timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, timestamp_tz, submessage_arena);
+    }
+    set_has_timestamp_tz();
+    kind_.timestamp_tz_ = timestamp_tz;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.timestamp_tz)
+}
+void DerivationExpression::clear_timestamp_tz() {
+  if (_internal_has_timestamp_tz()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.timestamp_tz_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_uuid(::substrait::Type_UUID* uuid) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (uuid) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(uuid));
+    if (message_arena != submessage_arena) {
+      uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, uuid, submessage_arena);
+    }
+    set_has_uuid();
+    kind_.uuid_ = uuid;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.uuid)
+}
+void DerivationExpression::clear_uuid() {
+  if (_internal_has_uuid()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.uuid_;
+    }
+    clear_has_kind();
+  }
+}
+void DerivationExpression::set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (fixed_char) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionFixedChar>::GetOwningArena(fixed_char);
+    if (message_arena != submessage_arena) {
+      fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fixed_char, submessage_arena);
+    }
+    set_has_fixed_char();
+    kind_.fixed_char_ = fixed_char;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fixed_char)
+}
+void DerivationExpression::set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (varchar) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionVarChar>::GetOwningArena(varchar);
+    if (message_arena != submessage_arena) {
+      varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, varchar, submessage_arena);
+    }
+    set_has_varchar();
+    kind_.varchar_ = varchar;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.varchar)
+}
+void DerivationExpression::set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (fixed_binary) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionFixedBinary>::GetOwningArena(fixed_binary);
+    if (message_arena != submessage_arena) {
+      fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, fixed_binary, submessage_arena);
+    }
+    set_has_fixed_binary();
+    kind_.fixed_binary_ = fixed_binary;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fixed_binary)
+}
+void DerivationExpression::set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (decimal) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionDecimal>::GetOwningArena(decimal);
+    if (message_arena != submessage_arena) {
+      decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, decimal, submessage_arena);
+    }
+    set_has_decimal();
+    kind_.decimal_ = decimal;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.decimal)
+}
+void DerivationExpression::set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (struct_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionStruct>::GetOwningArena(struct_);
+    if (message_arena != submessage_arena) {
+      struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, struct_, submessage_arena);
+    }
+    set_has_struct_();
+    kind_.struct__ = struct_;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.struct)
+}
+void DerivationExpression::set_allocated_list(::substrait::DerivationExpression_ExpressionList* list) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (list) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionList>::GetOwningArena(list);
+    if (message_arena != submessage_arena) {
+      list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, list, submessage_arena);
+    }
+    set_has_list();
+    kind_.list_ = list;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.list)
+}
+void DerivationExpression::set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (map) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionMap>::GetOwningArena(map);
+    if (message_arena != submessage_arena) {
+      map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, map, submessage_arena);
+    }
+    set_has_map();
+    kind_.map_ = map;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.map)
+}
+void DerivationExpression::set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (unary_op) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_UnaryOp>::GetOwningArena(unary_op);
+    if (message_arena != submessage_arena) {
+      unary_op = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, unary_op, submessage_arena);
+    }
+    set_has_unary_op();
+    kind_.unary_op_ = unary_op;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.unary_op)
+}
+void DerivationExpression::set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (binary_op) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_BinaryOp>::GetOwningArena(binary_op);
+    if (message_arena != submessage_arena) {
+      binary_op = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, binary_op, submessage_arena);
+    }
+    set_has_binary_op();
+    kind_.binary_op_ = binary_op;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.binary_op)
+}
+void DerivationExpression::set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (if_else) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_IfElse>::GetOwningArena(if_else);
+    if (message_arena != submessage_arena) {
+      if_else = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, if_else, submessage_arena);
+    }
+    set_has_if_else();
+    kind_.if_else_ = if_else;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.if_else)
+}
+void DerivationExpression::set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  clear_kind();
+  if (return_program) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ReturnProgram>::GetOwningArena(return_program);
+    if (message_arena != submessage_arena) {
+      return_program = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, return_program, submessage_arena);
+    }
+    set_has_return_program();
+    kind_.return_program_ = return_program;
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.return_program)
+}
+DerivationExpression::DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                         bool is_message_owned)
+  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+  SharedCtor();
+  if (!is_message_owned) {
+    RegisterArenaDtor(arena);
+  }
+  // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression)
+}
+DerivationExpression::DerivationExpression(const DerivationExpression& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message() {
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+  clear_has_kind();
+  switch (from.kind_case()) {
+    case kBool: {
+      _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_());
+      break;
+    }
+    case kI8: {
+      _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8());
+      break;
+    }
+    case kI16: {
+      _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16());
+      break;
+    }
+    case kI32: {
+      _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32());
+      break;
+    }
+    case kI64: {
+      _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64());
+      break;
+    }
+    case kFp32: {
+      _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32());
+      break;
+    }
+    case kFp64: {
+      _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64());
+      break;
+    }
+    case kString: {
+      _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string());
+      break;
+    }
+    case kBinary: {
+      _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary());
+      break;
+    }
+    case kTimestamp: {
+      _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp());
+      break;
+    }
+    case kDate: {
+      _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date());
+      break;
+    }
+    case kTime: {
+      _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time());
+      break;
+    }
+    case kIntervalYear: {
+      _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year());
+      break;
+    }
+    case kIntervalDay: {
+      _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day());
+      break;
+    }
+    case kTimestampTz: {
+      _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz());
+      break;
+    }
+    case kUuid: {
+      _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid());
+      break;
+    }
+    case kFixedChar: {
+      _internal_mutable_fixed_char()->::substrait::DerivationExpression_ExpressionFixedChar::MergeFrom(from._internal_fixed_char());
+      break;
+    }
+    case kVarchar: {
+      _internal_mutable_varchar()->::substrait::DerivationExpression_ExpressionVarChar::MergeFrom(from._internal_varchar());
+      break;
+    }
+    case kFixedBinary: {
+      _internal_mutable_fixed_binary()->::substrait::DerivationExpression_ExpressionFixedBinary::MergeFrom(from._internal_fixed_binary());
+      break;
+    }
+    case kDecimal: {
+      _internal_mutable_decimal()->::substrait::DerivationExpression_ExpressionDecimal::MergeFrom(from._internal_decimal());
+      break;
+    }
+    case kStruct: {
+      _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_());
+      break;
+    }
+    case kList: {
+      _internal_mutable_list()->::substrait::DerivationExpression_ExpressionList::MergeFrom(from._internal_list());
+      break;
+    }
+    case kMap: {
+      _internal_mutable_map()->::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map());
+      break;
+    }
+    case kUserDefinedPointer: {
+      _internal_set_user_defined_pointer(from._internal_user_defined_pointer());
+      break;
+    }
+    case kTypeParameterName: {
+      _internal_set_type_parameter_name(from._internal_type_parameter_name());
+      break;
+    }
+    case kIntegerParameterName: {
+      _internal_set_integer_parameter_name(from._internal_integer_parameter_name());
+      break;
+    }
+    case kIntegerLiteral: {
+      _internal_set_integer_literal(from._internal_integer_literal());
+      break;
+    }
+    case kUnaryOp: {
+      _internal_mutable_unary_op()->::substrait::DerivationExpression_UnaryOp::MergeFrom(from._internal_unary_op());
+      break;
+    }
+    case kBinaryOp: {
+      _internal_mutable_binary_op()->::substrait::DerivationExpression_BinaryOp::MergeFrom(from._internal_binary_op());
+      break;
+    }
+    case kIfElse: {
+      _internal_mutable_if_else()->::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else());
+      break;
+    }
+    case kReturnProgram: {
+      _internal_mutable_return_program()->::substrait::DerivationExpression_ReturnProgram::MergeFrom(from._internal_return_program());
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression)
+}
+
+inline void DerivationExpression::SharedCtor() {
+clear_has_kind();
+}
+
+DerivationExpression::~DerivationExpression() {
+  // @@protoc_insertion_point(destructor:substrait.DerivationExpression)
+  if (GetArenaForAllocation() != nullptr) return;
+  SharedDtor();
+  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void DerivationExpression::SharedDtor() {
+  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+  if (has_kind()) {
+    clear_kind();
+  }
+}
+
+void DerivationExpression::ArenaDtor(void* object) {
+  DerivationExpression* _this = reinterpret_cast< DerivationExpression* >(object);
+  (void)_this;
+}
+void DerivationExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void DerivationExpression::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void DerivationExpression::clear_kind() {
+// @@protoc_insertion_point(one_of_clear_start:substrait.DerivationExpression)
+  switch (kind_case()) {
+    case kBool: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.bool__;
+      }
+      break;
+    }
+    case kI8: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.i8_;
+      }
+      break;
+    }
+    case kI16: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.i16_;
+      }
+      break;
+    }
+    case kI32: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.i32_;
+      }
+      break;
+    }
+    case kI64: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.i64_;
+      }
+      break;
+    }
+    case kFp32: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.fp32_;
+      }
+      break;
+    }
+    case kFp64: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.fp64_;
+      }
+      break;
+    }
+    case kString: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.string_;
+      }
+      break;
+    }
+    case kBinary: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.binary_;
+      }
+      break;
+    }
+    case kTimestamp: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.timestamp_;
+      }
+      break;
+    }
+    case kDate: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.date_;
+      }
+      break;
+    }
+    case kTime: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.time_;
+      }
+      break;
+    }
+    case kIntervalYear: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.interval_year_;
+      }
+      break;
+    }
+    case kIntervalDay: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.interval_day_;
+      }
+      break;
+    }
+    case kTimestampTz: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.timestamp_tz_;
+      }
+      break;
+    }
+    case kUuid: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.uuid_;
+      }
+      break;
+    }
+    case kFixedChar: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.fixed_char_;
+      }
+      break;
+    }
+    case kVarchar: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.varchar_;
+      }
+      break;
+    }
+    case kFixedBinary: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.fixed_binary_;
+      }
+      break;
+    }
+    case kDecimal: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.decimal_;
+      }
+      break;
+    }
+    case kStruct: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.struct__;
+      }
+      break;
+    }
+    case kList: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.list_;
+      }
+      break;
+    }
+    case kMap: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.map_;
+      }
+      break;
+    }
+    case kUserDefinedPointer: {
+      // No need to clear
+      break;
+    }
+    case kTypeParameterName: {
+      kind_.type_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+      break;
+    }
+    case kIntegerParameterName: {
+      kind_.integer_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+      break;
+    }
+    case kIntegerLiteral: {
+      // No need to clear
+      break;
+    }
+    case kUnaryOp: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.unary_op_;
+      }
+      break;
+    }
+    case kBinaryOp: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.binary_op_;
+      }
+      break;
+    }
+    case kIfElse: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.if_else_;
+      }
+      break;
+    }
+    case kReturnProgram: {
+      if (GetArenaForAllocation() == nullptr) {
+        delete kind_.return_program_;
+      }
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = KIND_NOT_SET;
+}
+
+
+void DerivationExpression::Clear() {
+// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression)
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  clear_kind();
+  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    uint32_t tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    switch (tag >> 3) {
+      // .substrait.Type.Boolean bool = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.I8 i8 = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.I16 i16 = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+          ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.I32 i32 = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.I64 i64 = 7;
+      case 7:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.FP32 fp32 = 10;
+      case 10:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.FP64 fp64 = 11;
+      case 11:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.String string = 12;
+      case 12:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+          ptr = ctx->ParseMessage(_internal_mutable_string(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Binary binary = 13;
+      case 13:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+          ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Timestamp timestamp = 14;
+      case 14:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 114)) {
+          ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Date date = 16;
+      case 16:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 130)) {
+          ptr = ctx->ParseMessage(_internal_mutable_date(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.Time time = 17;
+      case 17:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 138)) {
+          ptr = ctx->ParseMessage(_internal_mutable_time(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.IntervalYear interval_year = 19;
+      case 19:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 154)) {
+          ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.IntervalDay interval_day = 20;
+      case 20:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 162)) {
+          ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21;
+      case 21:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 170)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression.ExpressionVarChar varchar = 22;
+      case 22:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 178)) {
+          ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23;
+      case 23:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 186)) {
+          ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression.ExpressionDecimal decimal = 24;
+      case 24:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 194)) {
+          ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression.ExpressionStruct struct = 25;
+      case 25:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 202)) {
+          ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression.ExpressionList list = 27;
+      case 27:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 218)) {
+          ptr = ctx->ParseMessage(_internal_mutable_list(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression.ExpressionMap map = 28;
+      case 28:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 226)) {
+          ptr = ctx->ParseMessage(_internal_mutable_map(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.TimestampTZ timestamp_tz = 29;
+      case 29:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 234)) {
+          ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // uint32 user_defined_pointer = 31;
+      case 31:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
+          _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.Type.UUID uuid = 32;
+      case 32:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 2)) {
+          ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string type_parameter_name = 33;
+      case 33:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+          auto str = _internal_mutable_type_parameter_name();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.type_parameter_name"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // string integer_parameter_name = 34;
+      case 34:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+          auto str = _internal_mutable_integer_parameter_name();
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.integer_parameter_name"));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // int32 integer_literal = 35;
+      case 35:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+          _internal_set_integer_literal(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression.UnaryOp unary_op = 36;
+      case 36:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_unary_op(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression.BinaryOp binary_op = 37;
+      case 37:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+          ptr = ctx->ParseMessage(_internal_mutable_binary_op(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression.IfElse if_else = 38;
+      case 38:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+          ptr = ctx->ParseMessage(_internal_mutable_if_else(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      // .substrait.DerivationExpression.ReturnProgram return_program = 39;
+      case 39:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+          ptr = ctx->ParseMessage(_internal_mutable_return_program(), ptr);
+          CHK_(ptr);
+        } else
+          goto handle_unusual;
+        continue;
+      default:
+        goto handle_unusual;
+    }  // switch
+  handle_unusual:
+    if ((tag == 0) || ((tag & 7) == 4)) {
+      CHK_(ptr);
+      ctx->SetLastTag(tag);
+      goto message_done;
+    }
+    ptr = UnknownFieldParse(
+        tag,
+        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+        ptr, ctx);
+    CHK_(ptr != nullptr);
+  }  // while
+message_done:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto message_done;
+#undef CHK_
+}
+
+uint8_t* DerivationExpression::_InternalSerialize(
+    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression)
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .substrait.Type.Boolean bool = 1;
+  if (_internal_has_bool_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        1, _Internal::bool_(this), target, stream);
+  }
+
+  // .substrait.Type.I8 i8 = 2;
+  if (_internal_has_i8()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        2, _Internal::i8(this), target, stream);
+  }
+
+  // .substrait.Type.I16 i16 = 3;
+  if (_internal_has_i16()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        3, _Internal::i16(this), target, stream);
+  }
+
+  // .substrait.Type.I32 i32 = 5;
+  if (_internal_has_i32()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        5, _Internal::i32(this), target, stream);
+  }
+
+  // .substrait.Type.I64 i64 = 7;
+  if (_internal_has_i64()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        7, _Internal::i64(this), target, stream);
+  }
+
+  // .substrait.Type.FP32 fp32 = 10;
+  if (_internal_has_fp32()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        10, _Internal::fp32(this), target, stream);
+  }
+
+  // .substrait.Type.FP64 fp64 = 11;
+  if (_internal_has_fp64()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        11, _Internal::fp64(this), target, stream);
+  }
+
+  // .substrait.Type.String string = 12;
+  if (_internal_has_string()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        12, _Internal::string(this), target, stream);
+  }
+
+  // .substrait.Type.Binary binary = 13;
+  if (_internal_has_binary()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        13, _Internal::binary(this), target, stream);
+  }
+
+  // .substrait.Type.Timestamp timestamp = 14;
+  if (_internal_has_timestamp()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        14, _Internal::timestamp(this), target, stream);
+  }
+
+  // .substrait.Type.Date date = 16;
+  if (_internal_has_date()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        16, _Internal::date(this), target, stream);
+  }
+
+  // .substrait.Type.Time time = 17;
+  if (_internal_has_time()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        17, _Internal::time(this), target, stream);
+  }
+
+  // .substrait.Type.IntervalYear interval_year = 19;
+  if (_internal_has_interval_year()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        19, _Internal::interval_year(this), target, stream);
+  }
+
+  // .substrait.Type.IntervalDay interval_day = 20;
+  if (_internal_has_interval_day()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        20, _Internal::interval_day(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21;
+  if (_internal_has_fixed_char()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        21, _Internal::fixed_char(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression.ExpressionVarChar varchar = 22;
+  if (_internal_has_varchar()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        22, _Internal::varchar(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23;
+  if (_internal_has_fixed_binary()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        23, _Internal::fixed_binary(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression.ExpressionDecimal decimal = 24;
+  if (_internal_has_decimal()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        24, _Internal::decimal(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression.ExpressionStruct struct = 25;
+  if (_internal_has_struct_()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        25, _Internal::struct_(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression.ExpressionList list = 27;
+  if (_internal_has_list()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        27, _Internal::list(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression.ExpressionMap map = 28;
+  if (_internal_has_map()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        28, _Internal::map(this), target, stream);
+  }
+
+  // .substrait.Type.TimestampTZ timestamp_tz = 29;
+  if (_internal_has_timestamp_tz()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        29, _Internal::timestamp_tz(this), target, stream);
+  }
+
+  // uint32 user_defined_pointer = 31;
+  if (_internal_has_user_defined_pointer()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_pointer(), target);
+  }
+
+  // .substrait.Type.UUID uuid = 32;
+  if (_internal_has_uuid()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        32, _Internal::uuid(this), target, stream);
+  }
+
+  // string type_parameter_name = 33;
+  if (_internal_has_type_parameter_name()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_type_parameter_name().data(), static_cast<int>(this->_internal_type_parameter_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.DerivationExpression.type_parameter_name");
+    target = stream->WriteStringMaybeAliased(
+        33, this->_internal_type_parameter_name(), target);
+  }
+
+  // string integer_parameter_name = 34;
+  if (_internal_has_integer_parameter_name()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->_internal_integer_parameter_name().data(), static_cast<int>(this->_internal_integer_parameter_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "substrait.DerivationExpression.integer_parameter_name");
+    target = stream->WriteStringMaybeAliased(
+        34, this->_internal_integer_parameter_name(), target);
+  }
+
+  // int32 integer_literal = 35;
+  if (_internal_has_integer_literal()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(35, this->_internal_integer_literal(), target);
+  }
+
+  // .substrait.DerivationExpression.UnaryOp unary_op = 36;
+  if (_internal_has_unary_op()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        36, _Internal::unary_op(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression.BinaryOp binary_op = 37;
+  if (_internal_has_binary_op()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        37, _Internal::binary_op(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression.IfElse if_else = 38;
+  if (_internal_has_if_else()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        38, _Internal::if_else(this), target, stream);
+  }
+
+  // .substrait.DerivationExpression.ReturnProgram return_program = 39;
+  if (_internal_has_return_program()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        39, _Internal::return_program(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression)
+  return target;
+}
+
+size_t DerivationExpression::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression)
+  size_t total_size = 0;
+
+  uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  switch (kind_case()) {
+    // .substrait.Type.Boolean bool = 1;
+    case kBool: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.bool__);
+      break;
+    }
+    // .substrait.Type.I8 i8 = 2;
+    case kI8: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.i8_);
+      break;
+    }
+    // .substrait.Type.I16 i16 = 3;
+    case kI16: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.i16_);
+      break;
+    }
+    // .substrait.Type.I32 i32 = 5;
+    case kI32: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.i32_);
+      break;
+    }
+    // .substrait.Type.I64 i64 = 7;
+    case kI64: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.i64_);
+      break;
+    }
+    // .substrait.Type.FP32 fp32 = 10;
+    case kFp32: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.fp32_);
+      break;
+    }
+    // .substrait.Type.FP64 fp64 = 11;
+    case kFp64: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.fp64_);
+      break;
+    }
+    // .substrait.Type.String string = 12;
+    case kString: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.string_);
+      break;
+    }
+    // .substrait.Type.Binary binary = 13;
+    case kBinary: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.binary_);
+      break;
+    }
+    // .substrait.Type.Timestamp timestamp = 14;
+    case kTimestamp: {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.timestamp_);
+      break;
+    }
+    // .substrait.Type.Date date = 16;
+    case kDate: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.date_);
+      break;
+    }
+    // .substrait.Type.Time time = 17;
+    case kTime: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.time_);
+      break;
+    }
+    // .substrait.Type.IntervalYear interval_year = 19;
+    case kIntervalYear: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.interval_year_);
+      break;
+    }
+    // .substrait.Type.IntervalDay interval_day = 20;
+    case kIntervalDay: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.interval_day_);
+      break;
+    }
+    // .substrait.Type.TimestampTZ timestamp_tz = 29;
+    case kTimestampTz: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.timestamp_tz_);
+      break;
+    }
+    // .substrait.Type.UUID uuid = 32;
+    case kUuid: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.uuid_);
+      break;
+    }
+    // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21;
+    case kFixedChar: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.fixed_char_);
+      break;
+    }
+    // .substrait.DerivationExpression.ExpressionVarChar varchar = 22;
+    case kVarchar: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.varchar_);
+      break;
+    }
+    // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23;
+    case kFixedBinary: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.fixed_binary_);
+      break;
+    }
+    // .substrait.DerivationExpression.ExpressionDecimal decimal = 24;
+    case kDecimal: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.decimal_);
+      break;
+    }
+    // .substrait.DerivationExpression.ExpressionStruct struct = 25;
+    case kStruct: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.struct__);
+      break;
+    }
+    // .substrait.DerivationExpression.ExpressionList list = 27;
+    case kList: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.list_);
+      break;
+    }
+    // .substrait.DerivationExpression.ExpressionMap map = 28;
+    case kMap: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.map_);
+      break;
+    }
+    // uint32 user_defined_pointer = 31;
+    case kUserDefinedPointer: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
+          this->_internal_user_defined_pointer());
+      break;
+    }
+    // string type_parameter_name = 33;
+    case kTypeParameterName: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_type_parameter_name());
+      break;
+    }
+    // string integer_parameter_name = 34;
+    case kIntegerParameterName: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+          this->_internal_integer_parameter_name());
+      break;
+    }
+    // int32 integer_literal = 35;
+    case kIntegerLiteral: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_integer_literal());
+      break;
+    }
+    // .substrait.DerivationExpression.UnaryOp unary_op = 36;
+    case kUnaryOp: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.unary_op_);
+      break;
+    }
+    // .substrait.DerivationExpression.BinaryOp binary_op = 37;
+    case kBinaryOp: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.binary_op_);
+      break;
+    }
+    // .substrait.DerivationExpression.IfElse if_else = 38;
+    case kIfElse: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.if_else_);
+      break;
+    }
+    // .substrait.DerivationExpression.ReturnProgram return_program = 39;
+    case kReturnProgram: {
+      total_size += 2 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *kind_.return_program_);
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression::_class_data_ = {
+    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+    DerivationExpression::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression::GetClassData() const { return &_class_data_; }
+
+void DerivationExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+  static_cast<DerivationExpression *>(to)->MergeFrom(
+      static_cast<const DerivationExpression &>(from));
+}
+
+
+void DerivationExpression::MergeFrom(const DerivationExpression& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression)
+  GOOGLE_DCHECK_NE(&from, this);
+  uint32_t cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  switch (from.kind_case()) {
+    case kBool: {
+      _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_());
+      break;
+    }
+    case kI8: {
+      _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8());
+      break;
+    }
+    case kI16: {
+      _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16());
+      break;
+    }
+    case kI32: {
+      _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32());
+      break;
+    }
+    case kI64: {
+      _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64());
+      break;
+    }
+    case kFp32: {
+      _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32());
+      break;
+    }
+    case kFp64: {
+      _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64());
+      break;
+    }
+    case kString: {
+      _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string());
+      break;
+    }
+    case kBinary: {
+      _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary());
+      break;
+    }
+    case kTimestamp: {
+      _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp());
+      break;
+    }
+    case kDate: {
+      _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date());
+      break;
+    }
+    case kTime: {
+      _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time());
+      break;
+    }
+    case kIntervalYear: {
+      _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year());
+      break;
+    }
+    case kIntervalDay: {
+      _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day());
+      break;
+    }
+    case kTimestampTz: {
+      _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz());
+      break;
+    }
+    case kUuid: {
+      _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid());
+      break;
+    }
+    case kFixedChar: {
+      _internal_mutable_fixed_char()->::substrait::DerivationExpression_ExpressionFixedChar::MergeFrom(from._internal_fixed_char());
+      break;
+    }
+    case kVarchar: {
+      _internal_mutable_varchar()->::substrait::DerivationExpression_ExpressionVarChar::MergeFrom(from._internal_varchar());
+      break;
+    }
+    case kFixedBinary: {
+      _internal_mutable_fixed_binary()->::substrait::DerivationExpression_ExpressionFixedBinary::MergeFrom(from._internal_fixed_binary());
+      break;
+    }
+    case kDecimal: {
+      _internal_mutable_decimal()->::substrait::DerivationExpression_ExpressionDecimal::MergeFrom(from._internal_decimal());
+      break;
+    }
+    case kStruct: {
+      _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_());
+      break;
+    }
+    case kList: {
+      _internal_mutable_list()->::substrait::DerivationExpression_ExpressionList::MergeFrom(from._internal_list());
+      break;
+    }
+    case kMap: {
+      _internal_mutable_map()->::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map());
+      break;
+    }
+    case kUserDefinedPointer: {
+      _internal_set_user_defined_pointer(from._internal_user_defined_pointer());
+      break;
+    }
+    case kTypeParameterName: {
+      _internal_set_type_parameter_name(from._internal_type_parameter_name());
+      break;
+    }
+    case kIntegerParameterName: {
+      _internal_set_integer_parameter_name(from._internal_integer_parameter_name());
+      break;
+    }
+    case kIntegerLiteral: {
+      _internal_set_integer_literal(from._internal_integer_literal());
+      break;
+    }
+    case kUnaryOp: {
+      _internal_mutable_unary_op()->::substrait::DerivationExpression_UnaryOp::MergeFrom(from._internal_unary_op());
+      break;
+    }
+    case kBinaryOp: {
+      _internal_mutable_binary_op()->::substrait::DerivationExpression_BinaryOp::MergeFrom(from._internal_binary_op());
+      break;
+    }
+    case kIfElse: {
+      _internal_mutable_if_else()->::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else());
+      break;
+    }
+    case kReturnProgram: {
+      _internal_mutable_return_program()->::substrait::DerivationExpression_ReturnProgram::MergeFrom(from._internal_return_program());
+      break;
+    }
+    case KIND_NOT_SET: {
+      break;
+    }
+  }
+  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void DerivationExpression::CopyFrom(const DerivationExpression& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DerivationExpression::IsInitialized() const {
+  return true;
+}
+
+void DerivationExpression::InternalSwap(DerivationExpression* other) {
+  using std::swap;
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(kind_, other->kind_);
+  swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression::GetMetadata() const {
+  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+      &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once,
+      file_level_metadata_substrait_2ftype_5fexpressions_2eproto[13]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionFixedChar* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedChar >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionFixedChar >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionVarChar >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionVarChar >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionFixedBinary* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedBinary >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionFixedBinary >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionDecimal* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionDecimal >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionDecimal >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionStruct >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionStruct >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionNamedStruct* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionNamedStruct >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionNamedStruct >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionList* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionList >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionList >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionMap* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionMap >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionMap >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_IfElse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_IfElse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_UnaryOp >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_UnaryOp >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_BinaryOp >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_BinaryOp >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ReturnProgram_Assignment* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram_Assignment >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ReturnProgram_Assignment >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ReturnProgram* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ReturnProgram >(arena);
+}
+template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression* Arena::CreateMaybeMessage< ::substrait::DerivationExpression >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::substrait::DerivationExpression >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/cpp/src/generated/substrait/type_expressions.pb.h b/cpp/src/generated/substrait/type_expressions.pb.h
new file mode 100644
index 000000000000..0548e41e6764
--- /dev/null
+++ b/cpp/src/generated/substrait/type_expressions.pb.h
@@ -0,0 +1,7743 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: substrait/type_expressions.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_5fexpressions_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_5fexpressions_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3019000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3019003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "substrait/type.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_substrait_2ftype_5fexpressions_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_substrait_2ftype_5fexpressions_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[14]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_5fexpressions_2eproto;
+namespace substrait {
+class DerivationExpression;
+struct DerivationExpressionDefaultTypeInternal;
+extern DerivationExpressionDefaultTypeInternal _DerivationExpression_default_instance_;
+class DerivationExpression_BinaryOp;
+struct DerivationExpression_BinaryOpDefaultTypeInternal;
+extern DerivationExpression_BinaryOpDefaultTypeInternal _DerivationExpression_BinaryOp_default_instance_;
+class DerivationExpression_ExpressionDecimal;
+struct DerivationExpression_ExpressionDecimalDefaultTypeInternal;
+extern DerivationExpression_ExpressionDecimalDefaultTypeInternal _DerivationExpression_ExpressionDecimal_default_instance_;
+class DerivationExpression_ExpressionFixedBinary;
+struct DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal;
+extern DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal _DerivationExpression_ExpressionFixedBinary_default_instance_;
+class DerivationExpression_ExpressionFixedChar;
+struct DerivationExpression_ExpressionFixedCharDefaultTypeInternal;
+extern DerivationExpression_ExpressionFixedCharDefaultTypeInternal _DerivationExpression_ExpressionFixedChar_default_instance_;
+class DerivationExpression_ExpressionList;
+struct DerivationExpression_ExpressionListDefaultTypeInternal;
+extern DerivationExpression_ExpressionListDefaultTypeInternal _DerivationExpression_ExpressionList_default_instance_;
+class DerivationExpression_ExpressionMap;
+struct DerivationExpression_ExpressionMapDefaultTypeInternal;
+extern DerivationExpression_ExpressionMapDefaultTypeInternal _DerivationExpression_ExpressionMap_default_instance_;
+class DerivationExpression_ExpressionNamedStruct;
+struct DerivationExpression_ExpressionNamedStructDefaultTypeInternal;
+extern DerivationExpression_ExpressionNamedStructDefaultTypeInternal _DerivationExpression_ExpressionNamedStruct_default_instance_;
+class DerivationExpression_ExpressionStruct;
+struct DerivationExpression_ExpressionStructDefaultTypeInternal;
+extern DerivationExpression_ExpressionStructDefaultTypeInternal _DerivationExpression_ExpressionStruct_default_instance_;
+class DerivationExpression_ExpressionVarChar;
+struct DerivationExpression_ExpressionVarCharDefaultTypeInternal;
+extern DerivationExpression_ExpressionVarCharDefaultTypeInternal _DerivationExpression_ExpressionVarChar_default_instance_;
+class DerivationExpression_IfElse;
+struct DerivationExpression_IfElseDefaultTypeInternal;
+extern DerivationExpression_IfElseDefaultTypeInternal _DerivationExpression_IfElse_default_instance_;
+class DerivationExpression_ReturnProgram;
+struct DerivationExpression_ReturnProgramDefaultTypeInternal;
+extern DerivationExpression_ReturnProgramDefaultTypeInternal _DerivationExpression_ReturnProgram_default_instance_;
+class DerivationExpression_ReturnProgram_Assignment;
+struct DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal;
+extern DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal _DerivationExpression_ReturnProgram_Assignment_default_instance_;
+class DerivationExpression_UnaryOp;
+struct DerivationExpression_UnaryOpDefaultTypeInternal;
+extern DerivationExpression_UnaryOpDefaultTypeInternal _DerivationExpression_UnaryOp_default_instance_;
+}  // namespace substrait
+PROTOBUF_NAMESPACE_OPEN
+template<> ::substrait::DerivationExpression* Arena::CreateMaybeMessage<::substrait::DerivationExpression>(Arena*);
+template<> ::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage<::substrait::DerivationExpression_BinaryOp>(Arena*);
+template<> ::substrait::DerivationExpression_ExpressionDecimal* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionDecimal>(Arena*);
+template<> ::substrait::DerivationExpression_ExpressionFixedBinary* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionFixedBinary>(Arena*);
+template<> ::substrait::DerivationExpression_ExpressionFixedChar* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionFixedChar>(Arena*);
+template<> ::substrait::DerivationExpression_ExpressionList* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionList>(Arena*);
+template<> ::substrait::DerivationExpression_ExpressionMap* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionMap>(Arena*);
+template<> ::substrait::DerivationExpression_ExpressionNamedStruct* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionNamedStruct>(Arena*);
+template<> ::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionStruct>(Arena*);
+template<> ::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionVarChar>(Arena*);
+template<> ::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage<::substrait::DerivationExpression_IfElse>(Arena*);
+template<> ::substrait::DerivationExpression_ReturnProgram* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ReturnProgram>(Arena*);
+template<> ::substrait::DerivationExpression_ReturnProgram_Assignment* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ReturnProgram_Assignment>(Arena*);
+template<> ::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage<::substrait::DerivationExpression_UnaryOp>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace substrait {
+
+enum DerivationExpression_UnaryOp_UnaryOpType : int {
+  DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED = 0,
+  DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT = 1,
+  DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool DerivationExpression_UnaryOp_UnaryOpType_IsValid(int value);
+constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MIN = DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED;
+constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MAX = DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT;
+constexpr int DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_ARRAYSIZE = DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_UnaryOp_UnaryOpType_descriptor();
+template<typename T>
+inline const std::string& DerivationExpression_UnaryOp_UnaryOpType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DerivationExpression_UnaryOp_UnaryOpType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DerivationExpression_UnaryOp_UnaryOpType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DerivationExpression_UnaryOp_UnaryOpType_descriptor(), enum_t_value);
+}
+inline bool DerivationExpression_UnaryOp_UnaryOpType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DerivationExpression_UnaryOp_UnaryOpType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DerivationExpression_UnaryOp_UnaryOpType>(
+    DerivationExpression_UnaryOp_UnaryOpType_descriptor(), name, value);
+}
+enum DerivationExpression_BinaryOp_BinaryOpType : int {
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED = 0,
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_PLUS = 1,
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MINUS = 2,
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MULTIPLY = 3,
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_DIVIDE = 4,
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MIN = 5,
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MAX = 6,
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_GREATER_THAN = 7,
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_LESS_THAN = 8,
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_AND = 9,
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_OR = 10,
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_EQUALS = 11,
+  DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS = 12,
+  DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
+  DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
+};
+bool DerivationExpression_BinaryOp_BinaryOpType_IsValid(int value);
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MIN = DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED;
+constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MAX = DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS;
+constexpr int DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_ARRAYSIZE = DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_BinaryOpType_descriptor();
+template<typename T>
+inline const std::string& DerivationExpression_BinaryOp_BinaryOpType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DerivationExpression_BinaryOp_BinaryOpType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DerivationExpression_BinaryOp_BinaryOpType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DerivationExpression_BinaryOp_BinaryOpType_descriptor(), enum_t_value);
+}
+inline bool DerivationExpression_BinaryOp_BinaryOpType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DerivationExpression_BinaryOp_BinaryOpType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DerivationExpression_BinaryOp_BinaryOpType>(
+    DerivationExpression_BinaryOp_BinaryOpType_descriptor(), name, value);
+}
+// ===================================================================
+
+class DerivationExpression_ExpressionFixedChar final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionFixedChar) */ {
+ public:
+  inline DerivationExpression_ExpressionFixedChar() : DerivationExpression_ExpressionFixedChar(nullptr) {}
+  ~DerivationExpression_ExpressionFixedChar() override;
+  explicit constexpr DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_ExpressionFixedChar(const DerivationExpression_ExpressionFixedChar& from);
+  DerivationExpression_ExpressionFixedChar(DerivationExpression_ExpressionFixedChar&& from) noexcept
+    : DerivationExpression_ExpressionFixedChar() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_ExpressionFixedChar& operator=(const DerivationExpression_ExpressionFixedChar& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_ExpressionFixedChar& operator=(DerivationExpression_ExpressionFixedChar&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_ExpressionFixedChar& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_ExpressionFixedChar* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_ExpressionFixedChar*>(
+               &_DerivationExpression_ExpressionFixedChar_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DerivationExpression_ExpressionFixedChar& a, DerivationExpression_ExpressionFixedChar& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_ExpressionFixedChar* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_ExpressionFixedChar* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_ExpressionFixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_ExpressionFixedChar>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_ExpressionFixedChar& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_ExpressionFixedChar& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_ExpressionFixedChar* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.ExpressionFixedChar";
+  }
+  protected:
+  explicit DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLengthFieldNumber = 1,
+    kVariationPointerFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // .substrait.DerivationExpression length = 1;
+  bool has_length() const;
+  private:
+  bool _internal_has_length() const;
+  public:
+  void clear_length();
+  const ::substrait::DerivationExpression& length() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_length();
+  ::substrait::DerivationExpression* mutable_length();
+  void set_allocated_length(::substrait::DerivationExpression* length);
+  private:
+  const ::substrait::DerivationExpression& _internal_length() const;
+  ::substrait::DerivationExpression* _internal_mutable_length();
+  public:
+  void unsafe_arena_set_allocated_length(
+      ::substrait::DerivationExpression* length);
+  ::substrait::DerivationExpression* unsafe_arena_release_length();
+
+  // uint32 variation_pointer = 2;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionFixedChar)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::DerivationExpression* length_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression_ExpressionVarChar final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionVarChar) */ {
+ public:
+  inline DerivationExpression_ExpressionVarChar() : DerivationExpression_ExpressionVarChar(nullptr) {}
+  ~DerivationExpression_ExpressionVarChar() override;
+  explicit constexpr DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_ExpressionVarChar(const DerivationExpression_ExpressionVarChar& from);
+  DerivationExpression_ExpressionVarChar(DerivationExpression_ExpressionVarChar&& from) noexcept
+    : DerivationExpression_ExpressionVarChar() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_ExpressionVarChar& operator=(const DerivationExpression_ExpressionVarChar& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_ExpressionVarChar& operator=(DerivationExpression_ExpressionVarChar&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_ExpressionVarChar& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_ExpressionVarChar* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_ExpressionVarChar*>(
+               &_DerivationExpression_ExpressionVarChar_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(DerivationExpression_ExpressionVarChar& a, DerivationExpression_ExpressionVarChar& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_ExpressionVarChar* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_ExpressionVarChar* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_ExpressionVarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_ExpressionVarChar>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_ExpressionVarChar& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_ExpressionVarChar& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_ExpressionVarChar* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.ExpressionVarChar";
+  }
+  protected:
+  explicit DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLengthFieldNumber = 1,
+    kVariationPointerFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // .substrait.DerivationExpression length = 1;
+  bool has_length() const;
+  private:
+  bool _internal_has_length() const;
+  public:
+  void clear_length();
+  const ::substrait::DerivationExpression& length() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_length();
+  ::substrait::DerivationExpression* mutable_length();
+  void set_allocated_length(::substrait::DerivationExpression* length);
+  private:
+  const ::substrait::DerivationExpression& _internal_length() const;
+  ::substrait::DerivationExpression* _internal_mutable_length();
+  public:
+  void unsafe_arena_set_allocated_length(
+      ::substrait::DerivationExpression* length);
+  ::substrait::DerivationExpression* unsafe_arena_release_length();
+
+  // uint32 variation_pointer = 2;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionVarChar)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::DerivationExpression* length_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression_ExpressionFixedBinary final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionFixedBinary) */ {
+ public:
+  inline DerivationExpression_ExpressionFixedBinary() : DerivationExpression_ExpressionFixedBinary(nullptr) {}
+  ~DerivationExpression_ExpressionFixedBinary() override;
+  explicit constexpr DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_ExpressionFixedBinary(const DerivationExpression_ExpressionFixedBinary& from);
+  DerivationExpression_ExpressionFixedBinary(DerivationExpression_ExpressionFixedBinary&& from) noexcept
+    : DerivationExpression_ExpressionFixedBinary() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_ExpressionFixedBinary& operator=(const DerivationExpression_ExpressionFixedBinary& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_ExpressionFixedBinary& operator=(DerivationExpression_ExpressionFixedBinary&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_ExpressionFixedBinary& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_ExpressionFixedBinary* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_ExpressionFixedBinary*>(
+               &_DerivationExpression_ExpressionFixedBinary_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(DerivationExpression_ExpressionFixedBinary& a, DerivationExpression_ExpressionFixedBinary& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_ExpressionFixedBinary* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_ExpressionFixedBinary* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_ExpressionFixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_ExpressionFixedBinary>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_ExpressionFixedBinary& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_ExpressionFixedBinary& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_ExpressionFixedBinary* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.ExpressionFixedBinary";
+  }
+  protected:
+  explicit DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLengthFieldNumber = 1,
+    kVariationPointerFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // .substrait.DerivationExpression length = 1;
+  bool has_length() const;
+  private:
+  bool _internal_has_length() const;
+  public:
+  void clear_length();
+  const ::substrait::DerivationExpression& length() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_length();
+  ::substrait::DerivationExpression* mutable_length();
+  void set_allocated_length(::substrait::DerivationExpression* length);
+  private:
+  const ::substrait::DerivationExpression& _internal_length() const;
+  ::substrait::DerivationExpression* _internal_mutable_length();
+  public:
+  void unsafe_arena_set_allocated_length(
+      ::substrait::DerivationExpression* length);
+  ::substrait::DerivationExpression* unsafe_arena_release_length();
+
+  // uint32 variation_pointer = 2;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionFixedBinary)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::DerivationExpression* length_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression_ExpressionDecimal final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionDecimal) */ {
+ public:
+  inline DerivationExpression_ExpressionDecimal() : DerivationExpression_ExpressionDecimal(nullptr) {}
+  ~DerivationExpression_ExpressionDecimal() override;
+  explicit constexpr DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_ExpressionDecimal(const DerivationExpression_ExpressionDecimal& from);
+  DerivationExpression_ExpressionDecimal(DerivationExpression_ExpressionDecimal&& from) noexcept
+    : DerivationExpression_ExpressionDecimal() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_ExpressionDecimal& operator=(const DerivationExpression_ExpressionDecimal& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_ExpressionDecimal& operator=(DerivationExpression_ExpressionDecimal&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_ExpressionDecimal& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_ExpressionDecimal* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_ExpressionDecimal*>(
+               &_DerivationExpression_ExpressionDecimal_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(DerivationExpression_ExpressionDecimal& a, DerivationExpression_ExpressionDecimal& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_ExpressionDecimal* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_ExpressionDecimal* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_ExpressionDecimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_ExpressionDecimal>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_ExpressionDecimal& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_ExpressionDecimal& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_ExpressionDecimal* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.ExpressionDecimal";
+  }
+  protected:
+  explicit DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kScaleFieldNumber = 1,
+    kPrecisionFieldNumber = 2,
+    kVariationPointerFieldNumber = 3,
+    kNullabilityFieldNumber = 4,
+  };
+  // .substrait.DerivationExpression scale = 1;
+  bool has_scale() const;
+  private:
+  bool _internal_has_scale() const;
+  public:
+  void clear_scale();
+  const ::substrait::DerivationExpression& scale() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_scale();
+  ::substrait::DerivationExpression* mutable_scale();
+  void set_allocated_scale(::substrait::DerivationExpression* scale);
+  private:
+  const ::substrait::DerivationExpression& _internal_scale() const;
+  ::substrait::DerivationExpression* _internal_mutable_scale();
+  public:
+  void unsafe_arena_set_allocated_scale(
+      ::substrait::DerivationExpression* scale);
+  ::substrait::DerivationExpression* unsafe_arena_release_scale();
+
+  // .substrait.DerivationExpression precision = 2;
+  bool has_precision() const;
+  private:
+  bool _internal_has_precision() const;
+  public:
+  void clear_precision();
+  const ::substrait::DerivationExpression& precision() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_precision();
+  ::substrait::DerivationExpression* mutable_precision();
+  void set_allocated_precision(::substrait::DerivationExpression* precision);
+  private:
+  const ::substrait::DerivationExpression& _internal_precision() const;
+  ::substrait::DerivationExpression* _internal_mutable_precision();
+  public:
+  void unsafe_arena_set_allocated_precision(
+      ::substrait::DerivationExpression* precision);
+  ::substrait::DerivationExpression* unsafe_arena_release_precision();
+
+  // uint32 variation_pointer = 3;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 4;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionDecimal)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::DerivationExpression* scale_;
+  ::substrait::DerivationExpression* precision_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression_ExpressionStruct final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionStruct) */ {
+ public:
+  inline DerivationExpression_ExpressionStruct() : DerivationExpression_ExpressionStruct(nullptr) {}
+  ~DerivationExpression_ExpressionStruct() override;
+  explicit constexpr DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_ExpressionStruct(const DerivationExpression_ExpressionStruct& from);
+  DerivationExpression_ExpressionStruct(DerivationExpression_ExpressionStruct&& from) noexcept
+    : DerivationExpression_ExpressionStruct() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_ExpressionStruct& operator=(const DerivationExpression_ExpressionStruct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_ExpressionStruct& operator=(DerivationExpression_ExpressionStruct&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_ExpressionStruct& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_ExpressionStruct* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_ExpressionStruct*>(
+               &_DerivationExpression_ExpressionStruct_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(DerivationExpression_ExpressionStruct& a, DerivationExpression_ExpressionStruct& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_ExpressionStruct* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_ExpressionStruct* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_ExpressionStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_ExpressionStruct>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_ExpressionStruct& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_ExpressionStruct& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_ExpressionStruct* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.ExpressionStruct";
+  }
+  protected:
+  explicit DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypesFieldNumber = 1,
+    kVariationPointerFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // repeated .substrait.DerivationExpression types = 1;
+  int types_size() const;
+  private:
+  int _internal_types_size() const;
+  public:
+  void clear_types();
+  ::substrait::DerivationExpression* mutable_types(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >*
+      mutable_types();
+  private:
+  const ::substrait::DerivationExpression& _internal_types(int index) const;
+  ::substrait::DerivationExpression* _internal_add_types();
+  public:
+  const ::substrait::DerivationExpression& types(int index) const;
+  ::substrait::DerivationExpression* add_types();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >&
+      types() const;
+
+  // uint32 variation_pointer = 2;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionStruct)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression > types_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression_ExpressionNamedStruct final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionNamedStruct) */ {
+ public:
+  inline DerivationExpression_ExpressionNamedStruct() : DerivationExpression_ExpressionNamedStruct(nullptr) {}
+  ~DerivationExpression_ExpressionNamedStruct() override;
+  explicit constexpr DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_ExpressionNamedStruct(const DerivationExpression_ExpressionNamedStruct& from);
+  DerivationExpression_ExpressionNamedStruct(DerivationExpression_ExpressionNamedStruct&& from) noexcept
+    : DerivationExpression_ExpressionNamedStruct() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_ExpressionNamedStruct& operator=(const DerivationExpression_ExpressionNamedStruct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_ExpressionNamedStruct& operator=(DerivationExpression_ExpressionNamedStruct&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_ExpressionNamedStruct& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_ExpressionNamedStruct* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_ExpressionNamedStruct*>(
+               &_DerivationExpression_ExpressionNamedStruct_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(DerivationExpression_ExpressionNamedStruct& a, DerivationExpression_ExpressionNamedStruct& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_ExpressionNamedStruct* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_ExpressionNamedStruct* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_ExpressionNamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_ExpressionNamedStruct>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_ExpressionNamedStruct& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_ExpressionNamedStruct& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_ExpressionNamedStruct* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.ExpressionNamedStruct";
+  }
+  protected:
+  explicit DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNamesFieldNumber = 1,
+    kStructFieldNumber = 2,
+  };
+  // repeated string names = 1;
+  int names_size() const;
+  private:
+  int _internal_names_size() const;
+  public:
+  void clear_names();
+  const std::string& names(int index) const;
+  std::string* mutable_names(int index);
+  void set_names(int index, const std::string& value);
+  void set_names(int index, std::string&& value);
+  void set_names(int index, const char* value);
+  void set_names(int index, const char* value, size_t size);
+  std::string* add_names();
+  void add_names(const std::string& value);
+  void add_names(std::string&& value);
+  void add_names(const char* value);
+  void add_names(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& names() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_names();
+  private:
+  const std::string& _internal_names(int index) const;
+  std::string* _internal_add_names();
+  public:
+
+  // .substrait.DerivationExpression.ExpressionStruct struct = 2;
+  bool has_struct_() const;
+  private:
+  bool _internal_has_struct_() const;
+  public:
+  void clear_struct_();
+  const ::substrait::DerivationExpression_ExpressionStruct& struct_() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionStruct* release_struct_();
+  ::substrait::DerivationExpression_ExpressionStruct* mutable_struct_();
+  void set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_);
+  private:
+  const ::substrait::DerivationExpression_ExpressionStruct& _internal_struct_() const;
+  ::substrait::DerivationExpression_ExpressionStruct* _internal_mutable_struct_();
+  public:
+  void unsafe_arena_set_allocated_struct_(
+      ::substrait::DerivationExpression_ExpressionStruct* struct_);
+  ::substrait::DerivationExpression_ExpressionStruct* unsafe_arena_release_struct_();
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionNamedStruct)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> names_;
+  ::substrait::DerivationExpression_ExpressionStruct* struct__;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression_ExpressionList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionList) */ {
+ public:
+  inline DerivationExpression_ExpressionList() : DerivationExpression_ExpressionList(nullptr) {}
+  ~DerivationExpression_ExpressionList() override;
+  explicit constexpr DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_ExpressionList(const DerivationExpression_ExpressionList& from);
+  DerivationExpression_ExpressionList(DerivationExpression_ExpressionList&& from) noexcept
+    : DerivationExpression_ExpressionList() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_ExpressionList& operator=(const DerivationExpression_ExpressionList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_ExpressionList& operator=(DerivationExpression_ExpressionList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_ExpressionList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_ExpressionList* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_ExpressionList*>(
+               &_DerivationExpression_ExpressionList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(DerivationExpression_ExpressionList& a, DerivationExpression_ExpressionList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_ExpressionList* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_ExpressionList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_ExpressionList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_ExpressionList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_ExpressionList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_ExpressionList& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_ExpressionList* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.ExpressionList";
+  }
+  protected:
+  explicit DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeFieldNumber = 1,
+    kVariationPointerFieldNumber = 2,
+    kNullabilityFieldNumber = 3,
+  };
+  // .substrait.DerivationExpression type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  const ::substrait::DerivationExpression& type() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_type();
+  ::substrait::DerivationExpression* mutable_type();
+  void set_allocated_type(::substrait::DerivationExpression* type);
+  private:
+  const ::substrait::DerivationExpression& _internal_type() const;
+  ::substrait::DerivationExpression* _internal_mutable_type();
+  public:
+  void unsafe_arena_set_allocated_type(
+      ::substrait::DerivationExpression* type);
+  ::substrait::DerivationExpression* unsafe_arena_release_type();
+
+  // uint32 variation_pointer = 2;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 3;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::DerivationExpression* type_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression_ExpressionMap final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionMap) */ {
+ public:
+  inline DerivationExpression_ExpressionMap() : DerivationExpression_ExpressionMap(nullptr) {}
+  ~DerivationExpression_ExpressionMap() override;
+  explicit constexpr DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_ExpressionMap(const DerivationExpression_ExpressionMap& from);
+  DerivationExpression_ExpressionMap(DerivationExpression_ExpressionMap&& from) noexcept
+    : DerivationExpression_ExpressionMap() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_ExpressionMap& operator=(const DerivationExpression_ExpressionMap& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_ExpressionMap& operator=(DerivationExpression_ExpressionMap&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_ExpressionMap& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_ExpressionMap* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_ExpressionMap*>(
+               &_DerivationExpression_ExpressionMap_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(DerivationExpression_ExpressionMap& a, DerivationExpression_ExpressionMap& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_ExpressionMap* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_ExpressionMap* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_ExpressionMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_ExpressionMap>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_ExpressionMap& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_ExpressionMap& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_ExpressionMap* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.ExpressionMap";
+  }
+  protected:
+  explicit DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 1,
+    kValueFieldNumber = 2,
+    kVariationPointerFieldNumber = 3,
+    kNullabilityFieldNumber = 4,
+  };
+  // .substrait.DerivationExpression key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::substrait::DerivationExpression& key() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_key();
+  ::substrait::DerivationExpression* mutable_key();
+  void set_allocated_key(::substrait::DerivationExpression* key);
+  private:
+  const ::substrait::DerivationExpression& _internal_key() const;
+  ::substrait::DerivationExpression* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::substrait::DerivationExpression* key);
+  ::substrait::DerivationExpression* unsafe_arena_release_key();
+
+  // .substrait.DerivationExpression value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const ::substrait::DerivationExpression& value() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_value();
+  ::substrait::DerivationExpression* mutable_value();
+  void set_allocated_value(::substrait::DerivationExpression* value);
+  private:
+  const ::substrait::DerivationExpression& _internal_value() const;
+  ::substrait::DerivationExpression* _internal_mutable_value();
+  public:
+  void unsafe_arena_set_allocated_value(
+      ::substrait::DerivationExpression* value);
+  ::substrait::DerivationExpression* unsafe_arena_release_value();
+
+  // uint32 variation_pointer = 3;
+  void clear_variation_pointer();
+  uint32_t variation_pointer() const;
+  void set_variation_pointer(uint32_t value);
+  private:
+  uint32_t _internal_variation_pointer() const;
+  void _internal_set_variation_pointer(uint32_t value);
+  public:
+
+  // .substrait.Type.Nullability nullability = 4;
+  void clear_nullability();
+  ::substrait::Type_Nullability nullability() const;
+  void set_nullability(::substrait::Type_Nullability value);
+  private:
+  ::substrait::Type_Nullability _internal_nullability() const;
+  void _internal_set_nullability(::substrait::Type_Nullability value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionMap)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::DerivationExpression* key_;
+  ::substrait::DerivationExpression* value_;
+  uint32_t variation_pointer_;
+  int nullability_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression_IfElse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.IfElse) */ {
+ public:
+  inline DerivationExpression_IfElse() : DerivationExpression_IfElse(nullptr) {}
+  ~DerivationExpression_IfElse() override;
+  explicit constexpr DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_IfElse(const DerivationExpression_IfElse& from);
+  DerivationExpression_IfElse(DerivationExpression_IfElse&& from) noexcept
+    : DerivationExpression_IfElse() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_IfElse& operator=(const DerivationExpression_IfElse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_IfElse& operator=(DerivationExpression_IfElse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_IfElse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_IfElse* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_IfElse*>(
+               &_DerivationExpression_IfElse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(DerivationExpression_IfElse& a, DerivationExpression_IfElse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_IfElse* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_IfElse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_IfElse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_IfElse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_IfElse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_IfElse& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_IfElse* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.IfElse";
+  }
+  protected:
+  explicit DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIfConditionFieldNumber = 1,
+    kIfReturnFieldNumber = 2,
+    kElseReturnFieldNumber = 3,
+  };
+  // .substrait.DerivationExpression if_condition = 1;
+  bool has_if_condition() const;
+  private:
+  bool _internal_has_if_condition() const;
+  public:
+  void clear_if_condition();
+  const ::substrait::DerivationExpression& if_condition() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_if_condition();
+  ::substrait::DerivationExpression* mutable_if_condition();
+  void set_allocated_if_condition(::substrait::DerivationExpression* if_condition);
+  private:
+  const ::substrait::DerivationExpression& _internal_if_condition() const;
+  ::substrait::DerivationExpression* _internal_mutable_if_condition();
+  public:
+  void unsafe_arena_set_allocated_if_condition(
+      ::substrait::DerivationExpression* if_condition);
+  ::substrait::DerivationExpression* unsafe_arena_release_if_condition();
+
+  // .substrait.DerivationExpression if_return = 2;
+  bool has_if_return() const;
+  private:
+  bool _internal_has_if_return() const;
+  public:
+  void clear_if_return();
+  const ::substrait::DerivationExpression& if_return() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_if_return();
+  ::substrait::DerivationExpression* mutable_if_return();
+  void set_allocated_if_return(::substrait::DerivationExpression* if_return);
+  private:
+  const ::substrait::DerivationExpression& _internal_if_return() const;
+  ::substrait::DerivationExpression* _internal_mutable_if_return();
+  public:
+  void unsafe_arena_set_allocated_if_return(
+      ::substrait::DerivationExpression* if_return);
+  ::substrait::DerivationExpression* unsafe_arena_release_if_return();
+
+  // .substrait.DerivationExpression else_return = 3;
+  bool has_else_return() const;
+  private:
+  bool _internal_has_else_return() const;
+  public:
+  void clear_else_return();
+  const ::substrait::DerivationExpression& else_return() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_else_return();
+  ::substrait::DerivationExpression* mutable_else_return();
+  void set_allocated_else_return(::substrait::DerivationExpression* else_return);
+  private:
+  const ::substrait::DerivationExpression& _internal_else_return() const;
+  ::substrait::DerivationExpression* _internal_mutable_else_return();
+  public:
+  void unsafe_arena_set_allocated_else_return(
+      ::substrait::DerivationExpression* else_return);
+  ::substrait::DerivationExpression* unsafe_arena_release_else_return();
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.IfElse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::DerivationExpression* if_condition_;
+  ::substrait::DerivationExpression* if_return_;
+  ::substrait::DerivationExpression* else_return_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression_UnaryOp final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.UnaryOp) */ {
+ public:
+  inline DerivationExpression_UnaryOp() : DerivationExpression_UnaryOp(nullptr) {}
+  ~DerivationExpression_UnaryOp() override;
+  explicit constexpr DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_UnaryOp(const DerivationExpression_UnaryOp& from);
+  DerivationExpression_UnaryOp(DerivationExpression_UnaryOp&& from) noexcept
+    : DerivationExpression_UnaryOp() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_UnaryOp& operator=(const DerivationExpression_UnaryOp& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_UnaryOp& operator=(DerivationExpression_UnaryOp&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_UnaryOp& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_UnaryOp* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_UnaryOp*>(
+               &_DerivationExpression_UnaryOp_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(DerivationExpression_UnaryOp& a, DerivationExpression_UnaryOp& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_UnaryOp* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_UnaryOp* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_UnaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_UnaryOp>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_UnaryOp& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_UnaryOp& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_UnaryOp* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.UnaryOp";
+  }
+  protected:
+  explicit DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DerivationExpression_UnaryOp_UnaryOpType UnaryOpType;
+  static constexpr UnaryOpType UNARY_OP_TYPE_UNSPECIFIED =
+    DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED;
+  static constexpr UnaryOpType UNARY_OP_TYPE_BOOLEAN_NOT =
+    DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT;
+  static inline bool UnaryOpType_IsValid(int value) {
+    return DerivationExpression_UnaryOp_UnaryOpType_IsValid(value);
+  }
+  static constexpr UnaryOpType UnaryOpType_MIN =
+    DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MIN;
+  static constexpr UnaryOpType UnaryOpType_MAX =
+    DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MAX;
+  static constexpr int UnaryOpType_ARRAYSIZE =
+    DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  UnaryOpType_descriptor() {
+    return DerivationExpression_UnaryOp_UnaryOpType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& UnaryOpType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, UnaryOpType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function UnaryOpType_Name.");
+    return DerivationExpression_UnaryOp_UnaryOpType_Name(enum_t_value);
+  }
+  static inline bool UnaryOpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      UnaryOpType* value) {
+    return DerivationExpression_UnaryOp_UnaryOpType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kArgFieldNumber = 2,
+    kOpTypeFieldNumber = 1,
+  };
+  // .substrait.DerivationExpression arg = 2;
+  bool has_arg() const;
+  private:
+  bool _internal_has_arg() const;
+  public:
+  void clear_arg();
+  const ::substrait::DerivationExpression& arg() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_arg();
+  ::substrait::DerivationExpression* mutable_arg();
+  void set_allocated_arg(::substrait::DerivationExpression* arg);
+  private:
+  const ::substrait::DerivationExpression& _internal_arg() const;
+  ::substrait::DerivationExpression* _internal_mutable_arg();
+  public:
+  void unsafe_arena_set_allocated_arg(
+      ::substrait::DerivationExpression* arg);
+  ::substrait::DerivationExpression* unsafe_arena_release_arg();
+
+  // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1;
+  void clear_op_type();
+  ::substrait::DerivationExpression_UnaryOp_UnaryOpType op_type() const;
+  void set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value);
+  private:
+  ::substrait::DerivationExpression_UnaryOp_UnaryOpType _internal_op_type() const;
+  void _internal_set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.UnaryOp)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::DerivationExpression* arg_;
+  int op_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression_BinaryOp final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.BinaryOp) */ {
+ public:
+  inline DerivationExpression_BinaryOp() : DerivationExpression_BinaryOp(nullptr) {}
+  ~DerivationExpression_BinaryOp() override;
+  explicit constexpr DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_BinaryOp(const DerivationExpression_BinaryOp& from);
+  DerivationExpression_BinaryOp(DerivationExpression_BinaryOp&& from) noexcept
+    : DerivationExpression_BinaryOp() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_BinaryOp& operator=(const DerivationExpression_BinaryOp& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_BinaryOp& operator=(DerivationExpression_BinaryOp&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_BinaryOp& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_BinaryOp* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_BinaryOp*>(
+               &_DerivationExpression_BinaryOp_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(DerivationExpression_BinaryOp& a, DerivationExpression_BinaryOp& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_BinaryOp* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_BinaryOp* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_BinaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_BinaryOp>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_BinaryOp& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_BinaryOp& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_BinaryOp* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.BinaryOp";
+  }
+  protected:
+  explicit DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DerivationExpression_BinaryOp_BinaryOpType BinaryOpType;
+  static constexpr BinaryOpType BINARY_OP_TYPE_UNSPECIFIED =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED;
+  static constexpr BinaryOpType BINARY_OP_TYPE_PLUS =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_PLUS;
+  static constexpr BinaryOpType BINARY_OP_TYPE_MINUS =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MINUS;
+  static constexpr BinaryOpType BINARY_OP_TYPE_MULTIPLY =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MULTIPLY;
+  static constexpr BinaryOpType BINARY_OP_TYPE_DIVIDE =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_DIVIDE;
+  static constexpr BinaryOpType BINARY_OP_TYPE_MIN =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MIN;
+  static constexpr BinaryOpType BINARY_OP_TYPE_MAX =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MAX;
+  static constexpr BinaryOpType BINARY_OP_TYPE_GREATER_THAN =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_GREATER_THAN;
+  static constexpr BinaryOpType BINARY_OP_TYPE_LESS_THAN =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_LESS_THAN;
+  static constexpr BinaryOpType BINARY_OP_TYPE_AND =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_AND;
+  static constexpr BinaryOpType BINARY_OP_TYPE_OR =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_OR;
+  static constexpr BinaryOpType BINARY_OP_TYPE_EQUALS =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_EQUALS;
+  static constexpr BinaryOpType BINARY_OP_TYPE_COVERS =
+    DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS;
+  static inline bool BinaryOpType_IsValid(int value) {
+    return DerivationExpression_BinaryOp_BinaryOpType_IsValid(value);
+  }
+  static constexpr BinaryOpType BinaryOpType_MIN =
+    DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MIN;
+  static constexpr BinaryOpType BinaryOpType_MAX =
+    DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MAX;
+  static constexpr int BinaryOpType_ARRAYSIZE =
+    DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  BinaryOpType_descriptor() {
+    return DerivationExpression_BinaryOp_BinaryOpType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& BinaryOpType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, BinaryOpType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function BinaryOpType_Name.");
+    return DerivationExpression_BinaryOp_BinaryOpType_Name(enum_t_value);
+  }
+  static inline bool BinaryOpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      BinaryOpType* value) {
+    return DerivationExpression_BinaryOp_BinaryOpType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kArg1FieldNumber = 2,
+    kArg2FieldNumber = 3,
+    kOpTypeFieldNumber = 1,
+  };
+  // .substrait.DerivationExpression arg1 = 2;
+  bool has_arg1() const;
+  private:
+  bool _internal_has_arg1() const;
+  public:
+  void clear_arg1();
+  const ::substrait::DerivationExpression& arg1() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_arg1();
+  ::substrait::DerivationExpression* mutable_arg1();
+  void set_allocated_arg1(::substrait::DerivationExpression* arg1);
+  private:
+  const ::substrait::DerivationExpression& _internal_arg1() const;
+  ::substrait::DerivationExpression* _internal_mutable_arg1();
+  public:
+  void unsafe_arena_set_allocated_arg1(
+      ::substrait::DerivationExpression* arg1);
+  ::substrait::DerivationExpression* unsafe_arena_release_arg1();
+
+  // .substrait.DerivationExpression arg2 = 3;
+  bool has_arg2() const;
+  private:
+  bool _internal_has_arg2() const;
+  public:
+  void clear_arg2();
+  const ::substrait::DerivationExpression& arg2() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_arg2();
+  ::substrait::DerivationExpression* mutable_arg2();
+  void set_allocated_arg2(::substrait::DerivationExpression* arg2);
+  private:
+  const ::substrait::DerivationExpression& _internal_arg2() const;
+  ::substrait::DerivationExpression* _internal_mutable_arg2();
+  public:
+  void unsafe_arena_set_allocated_arg2(
+      ::substrait::DerivationExpression* arg2);
+  ::substrait::DerivationExpression* unsafe_arena_release_arg2();
+
+  // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1;
+  void clear_op_type();
+  ::substrait::DerivationExpression_BinaryOp_BinaryOpType op_type() const;
+  void set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value);
+  private:
+  ::substrait::DerivationExpression_BinaryOp_BinaryOpType _internal_op_type() const;
+  void _internal_set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.BinaryOp)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::substrait::DerivationExpression* arg1_;
+  ::substrait::DerivationExpression* arg2_;
+  int op_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression_ReturnProgram_Assignment final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ReturnProgram.Assignment) */ {
+ public:
+  inline DerivationExpression_ReturnProgram_Assignment() : DerivationExpression_ReturnProgram_Assignment(nullptr) {}
+  ~DerivationExpression_ReturnProgram_Assignment() override;
+  explicit constexpr DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_ReturnProgram_Assignment(const DerivationExpression_ReturnProgram_Assignment& from);
+  DerivationExpression_ReturnProgram_Assignment(DerivationExpression_ReturnProgram_Assignment&& from) noexcept
+    : DerivationExpression_ReturnProgram_Assignment() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_ReturnProgram_Assignment& operator=(const DerivationExpression_ReturnProgram_Assignment& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_ReturnProgram_Assignment& operator=(DerivationExpression_ReturnProgram_Assignment&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_ReturnProgram_Assignment& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_ReturnProgram_Assignment* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_ReturnProgram_Assignment*>(
+               &_DerivationExpression_ReturnProgram_Assignment_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(DerivationExpression_ReturnProgram_Assignment& a, DerivationExpression_ReturnProgram_Assignment& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_ReturnProgram_Assignment* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_ReturnProgram_Assignment* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_ReturnProgram_Assignment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_ReturnProgram_Assignment>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_ReturnProgram_Assignment& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_ReturnProgram_Assignment& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_ReturnProgram_Assignment* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.ReturnProgram.Assignment";
+  }
+  protected:
+  explicit DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kExpressionFieldNumber = 2,
+  };
+  // string name = 1;
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_NODISCARD std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // .substrait.DerivationExpression expression = 2;
+  bool has_expression() const;
+  private:
+  bool _internal_has_expression() const;
+  public:
+  void clear_expression();
+  const ::substrait::DerivationExpression& expression() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_expression();
+  ::substrait::DerivationExpression* mutable_expression();
+  void set_allocated_expression(::substrait::DerivationExpression* expression);
+  private:
+  const ::substrait::DerivationExpression& _internal_expression() const;
+  ::substrait::DerivationExpression* _internal_mutable_expression();
+  public:
+  void unsafe_arena_set_allocated_expression(
+      ::substrait::DerivationExpression* expression);
+  ::substrait::DerivationExpression* unsafe_arena_release_expression();
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ReturnProgram.Assignment)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  ::substrait::DerivationExpression* expression_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression_ReturnProgram final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ReturnProgram) */ {
+ public:
+  inline DerivationExpression_ReturnProgram() : DerivationExpression_ReturnProgram(nullptr) {}
+  ~DerivationExpression_ReturnProgram() override;
+  explicit constexpr DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression_ReturnProgram(const DerivationExpression_ReturnProgram& from);
+  DerivationExpression_ReturnProgram(DerivationExpression_ReturnProgram&& from) noexcept
+    : DerivationExpression_ReturnProgram() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression_ReturnProgram& operator=(const DerivationExpression_ReturnProgram& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression_ReturnProgram& operator=(DerivationExpression_ReturnProgram&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression_ReturnProgram& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DerivationExpression_ReturnProgram* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression_ReturnProgram*>(
+               &_DerivationExpression_ReturnProgram_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(DerivationExpression_ReturnProgram& a, DerivationExpression_ReturnProgram& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression_ReturnProgram* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression_ReturnProgram* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression_ReturnProgram* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression_ReturnProgram>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression_ReturnProgram& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression_ReturnProgram& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression_ReturnProgram* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression.ReturnProgram";
+  }
+  protected:
+  explicit DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DerivationExpression_ReturnProgram_Assignment Assignment;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAssignmentsFieldNumber = 1,
+    kFinalExpressionFieldNumber = 2,
+  };
+  // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1;
+  int assignments_size() const;
+  private:
+  int _internal_assignments_size() const;
+  public:
+  void clear_assignments();
+  ::substrait::DerivationExpression_ReturnProgram_Assignment* mutable_assignments(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >*
+      mutable_assignments();
+  private:
+  const ::substrait::DerivationExpression_ReturnProgram_Assignment& _internal_assignments(int index) const;
+  ::substrait::DerivationExpression_ReturnProgram_Assignment* _internal_add_assignments();
+  public:
+  const ::substrait::DerivationExpression_ReturnProgram_Assignment& assignments(int index) const;
+  ::substrait::DerivationExpression_ReturnProgram_Assignment* add_assignments();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >&
+      assignments() const;
+
+  // .substrait.DerivationExpression final_expression = 2;
+  bool has_final_expression() const;
+  private:
+  bool _internal_has_final_expression() const;
+  public:
+  void clear_final_expression();
+  const ::substrait::DerivationExpression& final_expression() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_final_expression();
+  ::substrait::DerivationExpression* mutable_final_expression();
+  void set_allocated_final_expression(::substrait::DerivationExpression* final_expression);
+  private:
+  const ::substrait::DerivationExpression& _internal_final_expression() const;
+  ::substrait::DerivationExpression* _internal_mutable_final_expression();
+  public:
+  void unsafe_arena_set_allocated_final_expression(
+      ::substrait::DerivationExpression* final_expression);
+  ::substrait::DerivationExpression* unsafe_arena_release_final_expression();
+
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ReturnProgram)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment > assignments_;
+  ::substrait::DerivationExpression* final_expression_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DerivationExpression final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression) */ {
+ public:
+  inline DerivationExpression() : DerivationExpression(nullptr) {}
+  ~DerivationExpression() override;
+  explicit constexpr DerivationExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DerivationExpression(const DerivationExpression& from);
+  DerivationExpression(DerivationExpression&& from) noexcept
+    : DerivationExpression() {
+    *this = ::std::move(from);
+  }
+
+  inline DerivationExpression& operator=(const DerivationExpression& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DerivationExpression& operator=(DerivationExpression&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()
+  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+        && GetOwningArena() != nullptr
+  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
+    ) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DerivationExpression& default_instance() {
+    return *internal_default_instance();
+  }
+  enum KindCase {
+    kBool = 1,
+    kI8 = 2,
+    kI16 = 3,
+    kI32 = 5,
+    kI64 = 7,
+    kFp32 = 10,
+    kFp64 = 11,
+    kString = 12,
+    kBinary = 13,
+    kTimestamp = 14,
+    kDate = 16,
+    kTime = 17,
+    kIntervalYear = 19,
+    kIntervalDay = 20,
+    kTimestampTz = 29,
+    kUuid = 32,
+    kFixedChar = 21,
+    kVarchar = 22,
+    kFixedBinary = 23,
+    kDecimal = 24,
+    kStruct = 25,
+    kList = 27,
+    kMap = 28,
+    kUserDefinedPointer = 31,
+    kTypeParameterName = 33,
+    kIntegerParameterName = 34,
+    kIntegerLiteral = 35,
+    kUnaryOp = 36,
+    kBinaryOp = 37,
+    kIfElse = 38,
+    kReturnProgram = 39,
+    KIND_NOT_SET = 0,
+  };
+
+  static inline const DerivationExpression* internal_default_instance() {
+    return reinterpret_cast<const DerivationExpression*>(
+               &_DerivationExpression_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(DerivationExpression& a, DerivationExpression& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DerivationExpression* other) {
+    if (other == this) return;
+  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() != nullptr &&
+        GetOwningArena() == other->GetOwningArena()) {
+   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
+    if (GetOwningArena() == other->GetOwningArena()) {
+  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DerivationExpression* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DerivationExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DerivationExpression>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DerivationExpression& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DerivationExpression& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  uint8_t* _InternalSerialize(
+      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DerivationExpression* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "substrait.DerivationExpression";
+  }
+  protected:
+  explicit DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DerivationExpression_ExpressionFixedChar ExpressionFixedChar;
+  typedef DerivationExpression_ExpressionVarChar ExpressionVarChar;
+  typedef DerivationExpression_ExpressionFixedBinary ExpressionFixedBinary;
+  typedef DerivationExpression_ExpressionDecimal ExpressionDecimal;
+  typedef DerivationExpression_ExpressionStruct ExpressionStruct;
+  typedef DerivationExpression_ExpressionNamedStruct ExpressionNamedStruct;
+  typedef DerivationExpression_ExpressionList ExpressionList;
+  typedef DerivationExpression_ExpressionMap ExpressionMap;
+  typedef DerivationExpression_IfElse IfElse;
+  typedef DerivationExpression_UnaryOp UnaryOp;
+  typedef DerivationExpression_BinaryOp BinaryOp;
+  typedef DerivationExpression_ReturnProgram ReturnProgram;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBoolFieldNumber = 1,
+    kI8FieldNumber = 2,
+    kI16FieldNumber = 3,
+    kI32FieldNumber = 5,
+    kI64FieldNumber = 7,
+    kFp32FieldNumber = 10,
+    kFp64FieldNumber = 11,
+    kStringFieldNumber = 12,
+    kBinaryFieldNumber = 13,
+    kTimestampFieldNumber = 14,
+    kDateFieldNumber = 16,
+    kTimeFieldNumber = 17,
+    kIntervalYearFieldNumber = 19,
+    kIntervalDayFieldNumber = 20,
+    kTimestampTzFieldNumber = 29,
+    kUuidFieldNumber = 32,
+    kFixedCharFieldNumber = 21,
+    kVarcharFieldNumber = 22,
+    kFixedBinaryFieldNumber = 23,
+    kDecimalFieldNumber = 24,
+    kStructFieldNumber = 25,
+    kListFieldNumber = 27,
+    kMapFieldNumber = 28,
+    kUserDefinedPointerFieldNumber = 31,
+    kTypeParameterNameFieldNumber = 33,
+    kIntegerParameterNameFieldNumber = 34,
+    kIntegerLiteralFieldNumber = 35,
+    kUnaryOpFieldNumber = 36,
+    kBinaryOpFieldNumber = 37,
+    kIfElseFieldNumber = 38,
+    kReturnProgramFieldNumber = 39,
+  };
+  // .substrait.Type.Boolean bool = 1;
+  bool has_bool_() const;
+  private:
+  bool _internal_has_bool_() const;
+  public:
+  void clear_bool_();
+  const ::substrait::Type_Boolean& bool_() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Boolean* release_bool_();
+  ::substrait::Type_Boolean* mutable_bool_();
+  void set_allocated_bool_(::substrait::Type_Boolean* bool_);
+  private:
+  const ::substrait::Type_Boolean& _internal_bool_() const;
+  ::substrait::Type_Boolean* _internal_mutable_bool_();
+  public:
+  void unsafe_arena_set_allocated_bool_(
+      ::substrait::Type_Boolean* bool_);
+  ::substrait::Type_Boolean* unsafe_arena_release_bool_();
+
+  // .substrait.Type.I8 i8 = 2;
+  bool has_i8() const;
+  private:
+  bool _internal_has_i8() const;
+  public:
+  void clear_i8();
+  const ::substrait::Type_I8& i8() const;
+  PROTOBUF_NODISCARD ::substrait::Type_I8* release_i8();
+  ::substrait::Type_I8* mutable_i8();
+  void set_allocated_i8(::substrait::Type_I8* i8);
+  private:
+  const ::substrait::Type_I8& _internal_i8() const;
+  ::substrait::Type_I8* _internal_mutable_i8();
+  public:
+  void unsafe_arena_set_allocated_i8(
+      ::substrait::Type_I8* i8);
+  ::substrait::Type_I8* unsafe_arena_release_i8();
+
+  // .substrait.Type.I16 i16 = 3;
+  bool has_i16() const;
+  private:
+  bool _internal_has_i16() const;
+  public:
+  void clear_i16();
+  const ::substrait::Type_I16& i16() const;
+  PROTOBUF_NODISCARD ::substrait::Type_I16* release_i16();
+  ::substrait::Type_I16* mutable_i16();
+  void set_allocated_i16(::substrait::Type_I16* i16);
+  private:
+  const ::substrait::Type_I16& _internal_i16() const;
+  ::substrait::Type_I16* _internal_mutable_i16();
+  public:
+  void unsafe_arena_set_allocated_i16(
+      ::substrait::Type_I16* i16);
+  ::substrait::Type_I16* unsafe_arena_release_i16();
+
+  // .substrait.Type.I32 i32 = 5;
+  bool has_i32() const;
+  private:
+  bool _internal_has_i32() const;
+  public:
+  void clear_i32();
+  const ::substrait::Type_I32& i32() const;
+  PROTOBUF_NODISCARD ::substrait::Type_I32* release_i32();
+  ::substrait::Type_I32* mutable_i32();
+  void set_allocated_i32(::substrait::Type_I32* i32);
+  private:
+  const ::substrait::Type_I32& _internal_i32() const;
+  ::substrait::Type_I32* _internal_mutable_i32();
+  public:
+  void unsafe_arena_set_allocated_i32(
+      ::substrait::Type_I32* i32);
+  ::substrait::Type_I32* unsafe_arena_release_i32();
+
+  // .substrait.Type.I64 i64 = 7;
+  bool has_i64() const;
+  private:
+  bool _internal_has_i64() const;
+  public:
+  void clear_i64();
+  const ::substrait::Type_I64& i64() const;
+  PROTOBUF_NODISCARD ::substrait::Type_I64* release_i64();
+  ::substrait::Type_I64* mutable_i64();
+  void set_allocated_i64(::substrait::Type_I64* i64);
+  private:
+  const ::substrait::Type_I64& _internal_i64() const;
+  ::substrait::Type_I64* _internal_mutable_i64();
+  public:
+  void unsafe_arena_set_allocated_i64(
+      ::substrait::Type_I64* i64);
+  ::substrait::Type_I64* unsafe_arena_release_i64();
+
+  // .substrait.Type.FP32 fp32 = 10;
+  bool has_fp32() const;
+  private:
+  bool _internal_has_fp32() const;
+  public:
+  void clear_fp32();
+  const ::substrait::Type_FP32& fp32() const;
+  PROTOBUF_NODISCARD ::substrait::Type_FP32* release_fp32();
+  ::substrait::Type_FP32* mutable_fp32();
+  void set_allocated_fp32(::substrait::Type_FP32* fp32);
+  private:
+  const ::substrait::Type_FP32& _internal_fp32() const;
+  ::substrait::Type_FP32* _internal_mutable_fp32();
+  public:
+  void unsafe_arena_set_allocated_fp32(
+      ::substrait::Type_FP32* fp32);
+  ::substrait::Type_FP32* unsafe_arena_release_fp32();
+
+  // .substrait.Type.FP64 fp64 = 11;
+  bool has_fp64() const;
+  private:
+  bool _internal_has_fp64() const;
+  public:
+  void clear_fp64();
+  const ::substrait::Type_FP64& fp64() const;
+  PROTOBUF_NODISCARD ::substrait::Type_FP64* release_fp64();
+  ::substrait::Type_FP64* mutable_fp64();
+  void set_allocated_fp64(::substrait::Type_FP64* fp64);
+  private:
+  const ::substrait::Type_FP64& _internal_fp64() const;
+  ::substrait::Type_FP64* _internal_mutable_fp64();
+  public:
+  void unsafe_arena_set_allocated_fp64(
+      ::substrait::Type_FP64* fp64);
+  ::substrait::Type_FP64* unsafe_arena_release_fp64();
+
+  // .substrait.Type.String string = 12;
+  bool has_string() const;
+  private:
+  bool _internal_has_string() const;
+  public:
+  void clear_string();
+  const ::substrait::Type_String& string() const;
+  PROTOBUF_NODISCARD ::substrait::Type_String* release_string();
+  ::substrait::Type_String* mutable_string();
+  void set_allocated_string(::substrait::Type_String* string);
+  private:
+  const ::substrait::Type_String& _internal_string() const;
+  ::substrait::Type_String* _internal_mutable_string();
+  public:
+  void unsafe_arena_set_allocated_string(
+      ::substrait::Type_String* string);
+  ::substrait::Type_String* unsafe_arena_release_string();
+
+  // .substrait.Type.Binary binary = 13;
+  bool has_binary() const;
+  private:
+  bool _internal_has_binary() const;
+  public:
+  void clear_binary();
+  const ::substrait::Type_Binary& binary() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Binary* release_binary();
+  ::substrait::Type_Binary* mutable_binary();
+  void set_allocated_binary(::substrait::Type_Binary* binary);
+  private:
+  const ::substrait::Type_Binary& _internal_binary() const;
+  ::substrait::Type_Binary* _internal_mutable_binary();
+  public:
+  void unsafe_arena_set_allocated_binary(
+      ::substrait::Type_Binary* binary);
+  ::substrait::Type_Binary* unsafe_arena_release_binary();
+
+  // .substrait.Type.Timestamp timestamp = 14;
+  bool has_timestamp() const;
+  private:
+  bool _internal_has_timestamp() const;
+  public:
+  void clear_timestamp();
+  const ::substrait::Type_Timestamp& timestamp() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Timestamp* release_timestamp();
+  ::substrait::Type_Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp);
+  private:
+  const ::substrait::Type_Timestamp& _internal_timestamp() const;
+  ::substrait::Type_Timestamp* _internal_mutable_timestamp();
+  public:
+  void unsafe_arena_set_allocated_timestamp(
+      ::substrait::Type_Timestamp* timestamp);
+  ::substrait::Type_Timestamp* unsafe_arena_release_timestamp();
+
+  // .substrait.Type.Date date = 16;
+  bool has_date() const;
+  private:
+  bool _internal_has_date() const;
+  public:
+  void clear_date();
+  const ::substrait::Type_Date& date() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Date* release_date();
+  ::substrait::Type_Date* mutable_date();
+  void set_allocated_date(::substrait::Type_Date* date);
+  private:
+  const ::substrait::Type_Date& _internal_date() const;
+  ::substrait::Type_Date* _internal_mutable_date();
+  public:
+  void unsafe_arena_set_allocated_date(
+      ::substrait::Type_Date* date);
+  ::substrait::Type_Date* unsafe_arena_release_date();
+
+  // .substrait.Type.Time time = 17;
+  bool has_time() const;
+  private:
+  bool _internal_has_time() const;
+  public:
+  void clear_time();
+  const ::substrait::Type_Time& time() const;
+  PROTOBUF_NODISCARD ::substrait::Type_Time* release_time();
+  ::substrait::Type_Time* mutable_time();
+  void set_allocated_time(::substrait::Type_Time* time);
+  private:
+  const ::substrait::Type_Time& _internal_time() const;
+  ::substrait::Type_Time* _internal_mutable_time();
+  public:
+  void unsafe_arena_set_allocated_time(
+      ::substrait::Type_Time* time);
+  ::substrait::Type_Time* unsafe_arena_release_time();
+
+  // .substrait.Type.IntervalYear interval_year = 19;
+  bool has_interval_year() const;
+  private:
+  bool _internal_has_interval_year() const;
+  public:
+  void clear_interval_year();
+  const ::substrait::Type_IntervalYear& interval_year() const;
+  PROTOBUF_NODISCARD ::substrait::Type_IntervalYear* release_interval_year();
+  ::substrait::Type_IntervalYear* mutable_interval_year();
+  void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year);
+  private:
+  const ::substrait::Type_IntervalYear& _internal_interval_year() const;
+  ::substrait::Type_IntervalYear* _internal_mutable_interval_year();
+  public:
+  void unsafe_arena_set_allocated_interval_year(
+      ::substrait::Type_IntervalYear* interval_year);
+  ::substrait::Type_IntervalYear* unsafe_arena_release_interval_year();
+
+  // .substrait.Type.IntervalDay interval_day = 20;
+  bool has_interval_day() const;
+  private:
+  bool _internal_has_interval_day() const;
+  public:
+  void clear_interval_day();
+  const ::substrait::Type_IntervalDay& interval_day() const;
+  PROTOBUF_NODISCARD ::substrait::Type_IntervalDay* release_interval_day();
+  ::substrait::Type_IntervalDay* mutable_interval_day();
+  void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day);
+  private:
+  const ::substrait::Type_IntervalDay& _internal_interval_day() const;
+  ::substrait::Type_IntervalDay* _internal_mutable_interval_day();
+  public:
+  void unsafe_arena_set_allocated_interval_day(
+      ::substrait::Type_IntervalDay* interval_day);
+  ::substrait::Type_IntervalDay* unsafe_arena_release_interval_day();
+
+  // .substrait.Type.TimestampTZ timestamp_tz = 29;
+  bool has_timestamp_tz() const;
+  private:
+  bool _internal_has_timestamp_tz() const;
+  public:
+  void clear_timestamp_tz();
+  const ::substrait::Type_TimestampTZ& timestamp_tz() const;
+  PROTOBUF_NODISCARD ::substrait::Type_TimestampTZ* release_timestamp_tz();
+  ::substrait::Type_TimestampTZ* mutable_timestamp_tz();
+  void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz);
+  private:
+  const ::substrait::Type_TimestampTZ& _internal_timestamp_tz() const;
+  ::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz();
+  public:
+  void unsafe_arena_set_allocated_timestamp_tz(
+      ::substrait::Type_TimestampTZ* timestamp_tz);
+  ::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz();
+
+  // .substrait.Type.UUID uuid = 32;
+  bool has_uuid() const;
+  private:
+  bool _internal_has_uuid() const;
+  public:
+  void clear_uuid();
+  const ::substrait::Type_UUID& uuid() const;
+  PROTOBUF_NODISCARD ::substrait::Type_UUID* release_uuid();
+  ::substrait::Type_UUID* mutable_uuid();
+  void set_allocated_uuid(::substrait::Type_UUID* uuid);
+  private:
+  const ::substrait::Type_UUID& _internal_uuid() const;
+  ::substrait::Type_UUID* _internal_mutable_uuid();
+  public:
+  void unsafe_arena_set_allocated_uuid(
+      ::substrait::Type_UUID* uuid);
+  ::substrait::Type_UUID* unsafe_arena_release_uuid();
+
+  // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21;
+  bool has_fixed_char() const;
+  private:
+  bool _internal_has_fixed_char() const;
+  public:
+  void clear_fixed_char();
+  const ::substrait::DerivationExpression_ExpressionFixedChar& fixed_char() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionFixedChar* release_fixed_char();
+  ::substrait::DerivationExpression_ExpressionFixedChar* mutable_fixed_char();
+  void set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char);
+  private:
+  const ::substrait::DerivationExpression_ExpressionFixedChar& _internal_fixed_char() const;
+  ::substrait::DerivationExpression_ExpressionFixedChar* _internal_mutable_fixed_char();
+  public:
+  void unsafe_arena_set_allocated_fixed_char(
+      ::substrait::DerivationExpression_ExpressionFixedChar* fixed_char);
+  ::substrait::DerivationExpression_ExpressionFixedChar* unsafe_arena_release_fixed_char();
+
+  // .substrait.DerivationExpression.ExpressionVarChar varchar = 22;
+  bool has_varchar() const;
+  private:
+  bool _internal_has_varchar() const;
+  public:
+  void clear_varchar();
+  const ::substrait::DerivationExpression_ExpressionVarChar& varchar() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionVarChar* release_varchar();
+  ::substrait::DerivationExpression_ExpressionVarChar* mutable_varchar();
+  void set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar);
+  private:
+  const ::substrait::DerivationExpression_ExpressionVarChar& _internal_varchar() const;
+  ::substrait::DerivationExpression_ExpressionVarChar* _internal_mutable_varchar();
+  public:
+  void unsafe_arena_set_allocated_varchar(
+      ::substrait::DerivationExpression_ExpressionVarChar* varchar);
+  ::substrait::DerivationExpression_ExpressionVarChar* unsafe_arena_release_varchar();
+
+  // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23;
+  bool has_fixed_binary() const;
+  private:
+  bool _internal_has_fixed_binary() const;
+  public:
+  void clear_fixed_binary();
+  const ::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionFixedBinary* release_fixed_binary();
+  ::substrait::DerivationExpression_ExpressionFixedBinary* mutable_fixed_binary();
+  void set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary);
+  private:
+  const ::substrait::DerivationExpression_ExpressionFixedBinary& _internal_fixed_binary() const;
+  ::substrait::DerivationExpression_ExpressionFixedBinary* _internal_mutable_fixed_binary();
+  public:
+  void unsafe_arena_set_allocated_fixed_binary(
+      ::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary);
+  ::substrait::DerivationExpression_ExpressionFixedBinary* unsafe_arena_release_fixed_binary();
+
+  // .substrait.DerivationExpression.ExpressionDecimal decimal = 24;
+  bool has_decimal() const;
+  private:
+  bool _internal_has_decimal() const;
+  public:
+  void clear_decimal();
+  const ::substrait::DerivationExpression_ExpressionDecimal& decimal() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionDecimal* release_decimal();
+  ::substrait::DerivationExpression_ExpressionDecimal* mutable_decimal();
+  void set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal);
+  private:
+  const ::substrait::DerivationExpression_ExpressionDecimal& _internal_decimal() const;
+  ::substrait::DerivationExpression_ExpressionDecimal* _internal_mutable_decimal();
+  public:
+  void unsafe_arena_set_allocated_decimal(
+      ::substrait::DerivationExpression_ExpressionDecimal* decimal);
+  ::substrait::DerivationExpression_ExpressionDecimal* unsafe_arena_release_decimal();
+
+  // .substrait.DerivationExpression.ExpressionStruct struct = 25;
+  bool has_struct_() const;
+  private:
+  bool _internal_has_struct_() const;
+  public:
+  void clear_struct_();
+  const ::substrait::DerivationExpression_ExpressionStruct& struct_() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionStruct* release_struct_();
+  ::substrait::DerivationExpression_ExpressionStruct* mutable_struct_();
+  void set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_);
+  private:
+  const ::substrait::DerivationExpression_ExpressionStruct& _internal_struct_() const;
+  ::substrait::DerivationExpression_ExpressionStruct* _internal_mutable_struct_();
+  public:
+  void unsafe_arena_set_allocated_struct_(
+      ::substrait::DerivationExpression_ExpressionStruct* struct_);
+  ::substrait::DerivationExpression_ExpressionStruct* unsafe_arena_release_struct_();
+
+  // .substrait.DerivationExpression.ExpressionList list = 27;
+  bool has_list() const;
+  private:
+  bool _internal_has_list() const;
+  public:
+  void clear_list();
+  const ::substrait::DerivationExpression_ExpressionList& list() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionList* release_list();
+  ::substrait::DerivationExpression_ExpressionList* mutable_list();
+  void set_allocated_list(::substrait::DerivationExpression_ExpressionList* list);
+  private:
+  const ::substrait::DerivationExpression_ExpressionList& _internal_list() const;
+  ::substrait::DerivationExpression_ExpressionList* _internal_mutable_list();
+  public:
+  void unsafe_arena_set_allocated_list(
+      ::substrait::DerivationExpression_ExpressionList* list);
+  ::substrait::DerivationExpression_ExpressionList* unsafe_arena_release_list();
+
+  // .substrait.DerivationExpression.ExpressionMap map = 28;
+  bool has_map() const;
+  private:
+  bool _internal_has_map() const;
+  public:
+  void clear_map();
+  const ::substrait::DerivationExpression_ExpressionMap& map() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionMap* release_map();
+  ::substrait::DerivationExpression_ExpressionMap* mutable_map();
+  void set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map);
+  private:
+  const ::substrait::DerivationExpression_ExpressionMap& _internal_map() const;
+  ::substrait::DerivationExpression_ExpressionMap* _internal_mutable_map();
+  public:
+  void unsafe_arena_set_allocated_map(
+      ::substrait::DerivationExpression_ExpressionMap* map);
+  ::substrait::DerivationExpression_ExpressionMap* unsafe_arena_release_map();
+
+  // uint32 user_defined_pointer = 31;
+  bool has_user_defined_pointer() const;
+  private:
+  bool _internal_has_user_defined_pointer() const;
+  public:
+  void clear_user_defined_pointer();
+  uint32_t user_defined_pointer() const;
+  void set_user_defined_pointer(uint32_t value);
+  private:
+  uint32_t _internal_user_defined_pointer() const;
+  void _internal_set_user_defined_pointer(uint32_t value);
+  public:
+
+  // string type_parameter_name = 33;
+  bool has_type_parameter_name() const;
+  private:
+  bool _internal_has_type_parameter_name() const;
+  public:
+  void clear_type_parameter_name();
+  const std::string& type_parameter_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type_parameter_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type_parameter_name();
+  PROTOBUF_NODISCARD std::string* release_type_parameter_name();
+  void set_allocated_type_parameter_name(std::string* type_parameter_name);
+  private:
+  const std::string& _internal_type_parameter_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_parameter_name(const std::string& value);
+  std::string* _internal_mutable_type_parameter_name();
+  public:
+
+  // string integer_parameter_name = 34;
+  bool has_integer_parameter_name() const;
+  private:
+  bool _internal_has_integer_parameter_name() const;
+  public:
+  void clear_integer_parameter_name();
+  const std::string& integer_parameter_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_integer_parameter_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_integer_parameter_name();
+  PROTOBUF_NODISCARD std::string* release_integer_parameter_name();
+  void set_allocated_integer_parameter_name(std::string* integer_parameter_name);
+  private:
+  const std::string& _internal_integer_parameter_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_integer_parameter_name(const std::string& value);
+  std::string* _internal_mutable_integer_parameter_name();
+  public:
+
+  // int32 integer_literal = 35;
+  bool has_integer_literal() const;
+  private:
+  bool _internal_has_integer_literal() const;
+  public:
+  void clear_integer_literal();
+  int32_t integer_literal() const;
+  void set_integer_literal(int32_t value);
+  private:
+  int32_t _internal_integer_literal() const;
+  void _internal_set_integer_literal(int32_t value);
+  public:
+
+  // .substrait.DerivationExpression.UnaryOp unary_op = 36;
+  bool has_unary_op() const;
+  private:
+  bool _internal_has_unary_op() const;
+  public:
+  void clear_unary_op();
+  const ::substrait::DerivationExpression_UnaryOp& unary_op() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression_UnaryOp* release_unary_op();
+  ::substrait::DerivationExpression_UnaryOp* mutable_unary_op();
+  void set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op);
+  private:
+  const ::substrait::DerivationExpression_UnaryOp& _internal_unary_op() const;
+  ::substrait::DerivationExpression_UnaryOp* _internal_mutable_unary_op();
+  public:
+  void unsafe_arena_set_allocated_unary_op(
+      ::substrait::DerivationExpression_UnaryOp* unary_op);
+  ::substrait::DerivationExpression_UnaryOp* unsafe_arena_release_unary_op();
+
+  // .substrait.DerivationExpression.BinaryOp binary_op = 37;
+  bool has_binary_op() const;
+  private:
+  bool _internal_has_binary_op() const;
+  public:
+  void clear_binary_op();
+  const ::substrait::DerivationExpression_BinaryOp& binary_op() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression_BinaryOp* release_binary_op();
+  ::substrait::DerivationExpression_BinaryOp* mutable_binary_op();
+  void set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op);
+  private:
+  const ::substrait::DerivationExpression_BinaryOp& _internal_binary_op() const;
+  ::substrait::DerivationExpression_BinaryOp* _internal_mutable_binary_op();
+  public:
+  void unsafe_arena_set_allocated_binary_op(
+      ::substrait::DerivationExpression_BinaryOp* binary_op);
+  ::substrait::DerivationExpression_BinaryOp* unsafe_arena_release_binary_op();
+
+  // .substrait.DerivationExpression.IfElse if_else = 38;
+  bool has_if_else() const;
+  private:
+  bool _internal_has_if_else() const;
+  public:
+  void clear_if_else();
+  const ::substrait::DerivationExpression_IfElse& if_else() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression_IfElse* release_if_else();
+  ::substrait::DerivationExpression_IfElse* mutable_if_else();
+  void set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else);
+  private:
+  const ::substrait::DerivationExpression_IfElse& _internal_if_else() const;
+  ::substrait::DerivationExpression_IfElse* _internal_mutable_if_else();
+  public:
+  void unsafe_arena_set_allocated_if_else(
+      ::substrait::DerivationExpression_IfElse* if_else);
+  ::substrait::DerivationExpression_IfElse* unsafe_arena_release_if_else();
+
+  // .substrait.DerivationExpression.ReturnProgram return_program = 39;
+  bool has_return_program() const;
+  private:
+  bool _internal_has_return_program() const;
+  public:
+  void clear_return_program();
+  const ::substrait::DerivationExpression_ReturnProgram& return_program() const;
+  PROTOBUF_NODISCARD ::substrait::DerivationExpression_ReturnProgram* release_return_program();
+  ::substrait::DerivationExpression_ReturnProgram* mutable_return_program();
+  void set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program);
+  private:
+  const ::substrait::DerivationExpression_ReturnProgram& _internal_return_program() const;
+  ::substrait::DerivationExpression_ReturnProgram* _internal_mutable_return_program();
+  public:
+  void unsafe_arena_set_allocated_return_program(
+      ::substrait::DerivationExpression_ReturnProgram* return_program);
+  ::substrait::DerivationExpression_ReturnProgram* unsafe_arena_release_return_program();
+
+  void clear_kind();
+  KindCase kind_case() const;
+  // @@protoc_insertion_point(class_scope:substrait.DerivationExpression)
+ private:
+  class _Internal;
+  void set_has_bool_();
+  void set_has_i8();
+  void set_has_i16();
+  void set_has_i32();
+  void set_has_i64();
+  void set_has_fp32();
+  void set_has_fp64();
+  void set_has_string();
+  void set_has_binary();
+  void set_has_timestamp();
+  void set_has_date();
+  void set_has_time();
+  void set_has_interval_year();
+  void set_has_interval_day();
+  void set_has_timestamp_tz();
+  void set_has_uuid();
+  void set_has_fixed_char();
+  void set_has_varchar();
+  void set_has_fixed_binary();
+  void set_has_decimal();
+  void set_has_struct_();
+  void set_has_list();
+  void set_has_map();
+  void set_has_user_defined_pointer();
+  void set_has_type_parameter_name();
+  void set_has_integer_parameter_name();
+  void set_has_integer_literal();
+  void set_has_unary_op();
+  void set_has_binary_op();
+  void set_has_if_else();
+  void set_has_return_program();
+
+  inline bool has_kind() const;
+  inline void clear_has_kind();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union KindUnion {
+    constexpr KindUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::substrait::Type_Boolean* bool__;
+    ::substrait::Type_I8* i8_;
+    ::substrait::Type_I16* i16_;
+    ::substrait::Type_I32* i32_;
+    ::substrait::Type_I64* i64_;
+    ::substrait::Type_FP32* fp32_;
+    ::substrait::Type_FP64* fp64_;
+    ::substrait::Type_String* string_;
+    ::substrait::Type_Binary* binary_;
+    ::substrait::Type_Timestamp* timestamp_;
+    ::substrait::Type_Date* date_;
+    ::substrait::Type_Time* time_;
+    ::substrait::Type_IntervalYear* interval_year_;
+    ::substrait::Type_IntervalDay* interval_day_;
+    ::substrait::Type_TimestampTZ* timestamp_tz_;
+    ::substrait::Type_UUID* uuid_;
+    ::substrait::DerivationExpression_ExpressionFixedChar* fixed_char_;
+    ::substrait::DerivationExpression_ExpressionVarChar* varchar_;
+    ::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary_;
+    ::substrait::DerivationExpression_ExpressionDecimal* decimal_;
+    ::substrait::DerivationExpression_ExpressionStruct* struct__;
+    ::substrait::DerivationExpression_ExpressionList* list_;
+    ::substrait::DerivationExpression_ExpressionMap* map_;
+    uint32_t user_defined_pointer_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_parameter_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr integer_parameter_name_;
+    int32_t integer_literal_;
+    ::substrait::DerivationExpression_UnaryOp* unary_op_;
+    ::substrait::DerivationExpression_BinaryOp* binary_op_;
+    ::substrait::DerivationExpression_IfElse* if_else_;
+    ::substrait::DerivationExpression_ReturnProgram* return_program_;
+  } kind_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  uint32_t _oneof_case_[1];
+
+  friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DerivationExpression_ExpressionFixedChar
+
+// .substrait.DerivationExpression length = 1;
+inline bool DerivationExpression_ExpressionFixedChar::_internal_has_length() const {
+  return this != internal_default_instance() && length_ != nullptr;
+}
+inline bool DerivationExpression_ExpressionFixedChar::has_length() const {
+  return _internal_has_length();
+}
+inline void DerivationExpression_ExpressionFixedChar::clear_length() {
+  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
+    delete length_;
+  }
+  length_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::_internal_length() const {
+  const ::substrait::DerivationExpression* p = length_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::length() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.length)
+  return _internal_length();
+}
+inline void DerivationExpression_ExpressionFixedChar::unsafe_arena_set_allocated_length(
+    ::substrait::DerivationExpression* length) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_);
+  }
+  length_ = length;
+  if (length) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionFixedChar.length)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::release_length() {
+  
+  ::substrait::DerivationExpression* temp = length_;
+  length_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::unsafe_arena_release_length() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionFixedChar.length)
+  
+  ::substrait::DerivationExpression* temp = length_;
+  length_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::_internal_mutable_length() {
+  
+  if (length_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    length_ = p;
+  }
+  return length_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::mutable_length() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_length();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionFixedChar.length)
+  return _msg;
+}
+inline void DerivationExpression_ExpressionFixedChar::set_allocated_length(::substrait::DerivationExpression* length) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete length_;
+  }
+  if (length) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(length);
+    if (message_arena != submessage_arena) {
+      length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, length, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  length_ = length;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionFixedChar.length)
+}
+
+// uint32 variation_pointer = 2;
+inline void DerivationExpression_ExpressionFixedChar::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t DerivationExpression_ExpressionFixedChar::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t DerivationExpression_ExpressionFixedChar::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void DerivationExpression_ExpressionFixedChar::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void DerivationExpression_ExpressionFixedChar::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedChar.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void DerivationExpression_ExpressionFixedChar::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedChar::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedChar::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.nullability)
+  return _internal_nullability();
+}
+inline void DerivationExpression_ExpressionFixedChar::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void DerivationExpression_ExpressionFixedChar::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedChar.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression_ExpressionVarChar
+
+// .substrait.DerivationExpression length = 1;
+inline bool DerivationExpression_ExpressionVarChar::_internal_has_length() const {
+  return this != internal_default_instance() && length_ != nullptr;
+}
+inline bool DerivationExpression_ExpressionVarChar::has_length() const {
+  return _internal_has_length();
+}
+inline void DerivationExpression_ExpressionVarChar::clear_length() {
+  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
+    delete length_;
+  }
+  length_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::_internal_length() const {
+  const ::substrait::DerivationExpression* p = length_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::length() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.length)
+  return _internal_length();
+}
+inline void DerivationExpression_ExpressionVarChar::unsafe_arena_set_allocated_length(
+    ::substrait::DerivationExpression* length) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_);
+  }
+  length_ = length;
+  if (length) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionVarChar.length)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::release_length() {
+  
+  ::substrait::DerivationExpression* temp = length_;
+  length_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::unsafe_arena_release_length() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionVarChar.length)
+  
+  ::substrait::DerivationExpression* temp = length_;
+  length_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::_internal_mutable_length() {
+  
+  if (length_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    length_ = p;
+  }
+  return length_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::mutable_length() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_length();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionVarChar.length)
+  return _msg;
+}
+inline void DerivationExpression_ExpressionVarChar::set_allocated_length(::substrait::DerivationExpression* length) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete length_;
+  }
+  if (length) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(length);
+    if (message_arena != submessage_arena) {
+      length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, length, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  length_ = length;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionVarChar.length)
+}
+
+// uint32 variation_pointer = 2;
+inline void DerivationExpression_ExpressionVarChar::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t DerivationExpression_ExpressionVarChar::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t DerivationExpression_ExpressionVarChar::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void DerivationExpression_ExpressionVarChar::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void DerivationExpression_ExpressionVarChar::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionVarChar.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void DerivationExpression_ExpressionVarChar::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionVarChar::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionVarChar::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.nullability)
+  return _internal_nullability();
+}
+inline void DerivationExpression_ExpressionVarChar::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void DerivationExpression_ExpressionVarChar::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionVarChar.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression_ExpressionFixedBinary
+
+// .substrait.DerivationExpression length = 1;
+inline bool DerivationExpression_ExpressionFixedBinary::_internal_has_length() const {
+  return this != internal_default_instance() && length_ != nullptr;
+}
+inline bool DerivationExpression_ExpressionFixedBinary::has_length() const {
+  return _internal_has_length();
+}
+inline void DerivationExpression_ExpressionFixedBinary::clear_length() {
+  if (GetArenaForAllocation() == nullptr && length_ != nullptr) {
+    delete length_;
+  }
+  length_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::_internal_length() const {
+  const ::substrait::DerivationExpression* p = length_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::length() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.length)
+  return _internal_length();
+}
+inline void DerivationExpression_ExpressionFixedBinary::unsafe_arena_set_allocated_length(
+    ::substrait::DerivationExpression* length) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_);
+  }
+  length_ = length;
+  if (length) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionFixedBinary.length)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::release_length() {
+  
+  ::substrait::DerivationExpression* temp = length_;
+  length_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::unsafe_arena_release_length() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionFixedBinary.length)
+  
+  ::substrait::DerivationExpression* temp = length_;
+  length_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::_internal_mutable_length() {
+  
+  if (length_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    length_ = p;
+  }
+  return length_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::mutable_length() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_length();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionFixedBinary.length)
+  return _msg;
+}
+inline void DerivationExpression_ExpressionFixedBinary::set_allocated_length(::substrait::DerivationExpression* length) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete length_;
+  }
+  if (length) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(length);
+    if (message_arena != submessage_arena) {
+      length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, length, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  length_ = length;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionFixedBinary.length)
+}
+
+// uint32 variation_pointer = 2;
+inline void DerivationExpression_ExpressionFixedBinary::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t DerivationExpression_ExpressionFixedBinary::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t DerivationExpression_ExpressionFixedBinary::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void DerivationExpression_ExpressionFixedBinary::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void DerivationExpression_ExpressionFixedBinary::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void DerivationExpression_ExpressionFixedBinary::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedBinary::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedBinary::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.nullability)
+  return _internal_nullability();
+}
+inline void DerivationExpression_ExpressionFixedBinary::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void DerivationExpression_ExpressionFixedBinary::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedBinary.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression_ExpressionDecimal
+
+// .substrait.DerivationExpression scale = 1;
+inline bool DerivationExpression_ExpressionDecimal::_internal_has_scale() const {
+  return this != internal_default_instance() && scale_ != nullptr;
+}
+inline bool DerivationExpression_ExpressionDecimal::has_scale() const {
+  return _internal_has_scale();
+}
+inline void DerivationExpression_ExpressionDecimal::clear_scale() {
+  if (GetArenaForAllocation() == nullptr && scale_ != nullptr) {
+    delete scale_;
+  }
+  scale_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_internal_scale() const {
+  const ::substrait::DerivationExpression* p = scale_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::scale() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.scale)
+  return _internal_scale();
+}
+inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_scale(
+    ::substrait::DerivationExpression* scale) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_);
+  }
+  scale_ = scale;
+  if (scale) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionDecimal.scale)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::release_scale() {
+  
+  ::substrait::DerivationExpression* temp = scale_;
+  scale_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_scale() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionDecimal.scale)
+  
+  ::substrait::DerivationExpression* temp = scale_;
+  scale_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_scale() {
+  
+  if (scale_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    scale_ = p;
+  }
+  return scale_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_scale() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_scale();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionDecimal.scale)
+  return _msg;
+}
+inline void DerivationExpression_ExpressionDecimal::set_allocated_scale(::substrait::DerivationExpression* scale) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete scale_;
+  }
+  if (scale) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(scale);
+    if (message_arena != submessage_arena) {
+      scale = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, scale, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  scale_ = scale;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionDecimal.scale)
+}
+
+// .substrait.DerivationExpression precision = 2;
+inline bool DerivationExpression_ExpressionDecimal::_internal_has_precision() const {
+  return this != internal_default_instance() && precision_ != nullptr;
+}
+inline bool DerivationExpression_ExpressionDecimal::has_precision() const {
+  return _internal_has_precision();
+}
+inline void DerivationExpression_ExpressionDecimal::clear_precision() {
+  if (GetArenaForAllocation() == nullptr && precision_ != nullptr) {
+    delete precision_;
+  }
+  precision_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_internal_precision() const {
+  const ::substrait::DerivationExpression* p = precision_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::precision() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.precision)
+  return _internal_precision();
+}
+inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_precision(
+    ::substrait::DerivationExpression* precision) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(precision_);
+  }
+  precision_ = precision;
+  if (precision) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionDecimal.precision)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::release_precision() {
+  
+  ::substrait::DerivationExpression* temp = precision_;
+  precision_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_precision() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionDecimal.precision)
+  
+  ::substrait::DerivationExpression* temp = precision_;
+  precision_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_precision() {
+  
+  if (precision_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    precision_ = p;
+  }
+  return precision_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_precision() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_precision();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionDecimal.precision)
+  return _msg;
+}
+inline void DerivationExpression_ExpressionDecimal::set_allocated_precision(::substrait::DerivationExpression* precision) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete precision_;
+  }
+  if (precision) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(precision);
+    if (message_arena != submessage_arena) {
+      precision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, precision, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  precision_ = precision;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionDecimal.precision)
+}
+
+// uint32 variation_pointer = 3;
+inline void DerivationExpression_ExpressionDecimal::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t DerivationExpression_ExpressionDecimal::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t DerivationExpression_ExpressionDecimal::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void DerivationExpression_ExpressionDecimal::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void DerivationExpression_ExpressionDecimal::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionDecimal.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 4;
+inline void DerivationExpression_ExpressionDecimal::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionDecimal::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionDecimal::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.nullability)
+  return _internal_nullability();
+}
+inline void DerivationExpression_ExpressionDecimal::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void DerivationExpression_ExpressionDecimal::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionDecimal.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression_ExpressionStruct
+
+// repeated .substrait.DerivationExpression types = 1;
+inline int DerivationExpression_ExpressionStruct::_internal_types_size() const {
+  return types_.size();
+}
+inline int DerivationExpression_ExpressionStruct::types_size() const {
+  return _internal_types_size();
+}
+inline void DerivationExpression_ExpressionStruct::clear_types() {
+  types_.Clear();
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::mutable_types(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionStruct.types)
+  return types_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >*
+DerivationExpression_ExpressionStruct::mutable_types() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.DerivationExpression.ExpressionStruct.types)
+  return &types_;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionStruct::_internal_types(int index) const {
+  return types_.Get(index);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionStruct::types(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.types)
+  return _internal_types(index);
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::_internal_add_types() {
+  return types_.Add();
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::add_types() {
+  ::substrait::DerivationExpression* _add = _internal_add_types();
+  // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionStruct.types)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >&
+DerivationExpression_ExpressionStruct::types() const {
+  // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ExpressionStruct.types)
+  return types_;
+}
+
+// uint32 variation_pointer = 2;
+inline void DerivationExpression_ExpressionStruct::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t DerivationExpression_ExpressionStruct::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t DerivationExpression_ExpressionStruct::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void DerivationExpression_ExpressionStruct::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void DerivationExpression_ExpressionStruct::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionStruct.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void DerivationExpression_ExpressionStruct::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionStruct::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionStruct::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.nullability)
+  return _internal_nullability();
+}
+inline void DerivationExpression_ExpressionStruct::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void DerivationExpression_ExpressionStruct::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionStruct.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression_ExpressionNamedStruct
+
+// repeated string names = 1;
+inline int DerivationExpression_ExpressionNamedStruct::_internal_names_size() const {
+  return names_.size();
+}
+inline int DerivationExpression_ExpressionNamedStruct::names_size() const {
+  return _internal_names_size();
+}
+inline void DerivationExpression_ExpressionNamedStruct::clear_names() {
+  names_.Clear();
+}
+inline std::string* DerivationExpression_ExpressionNamedStruct::add_names() {
+  std::string* _s = _internal_add_names();
+  // @@protoc_insertion_point(field_add_mutable:substrait.DerivationExpression.ExpressionNamedStruct.names)
+  return _s;
+}
+inline const std::string& DerivationExpression_ExpressionNamedStruct::_internal_names(int index) const {
+  return names_.Get(index);
+}
+inline const std::string& DerivationExpression_ExpressionNamedStruct::names(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionNamedStruct.names)
+  return _internal_names(index);
+}
+inline std::string* DerivationExpression_ExpressionNamedStruct::mutable_names(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionNamedStruct.names)
+  return names_.Mutable(index);
+}
+inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const std::string& value) {
+  names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionNamedStruct.names)
+}
+inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, std::string&& value) {
+  names_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionNamedStruct.names)
+}
+inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:substrait.DerivationExpression.ExpressionNamedStruct.names)
+}
+inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const char* value, size_t size) {
+  names_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:substrait.DerivationExpression.ExpressionNamedStruct.names)
+}
+inline std::string* DerivationExpression_ExpressionNamedStruct::_internal_add_names() {
+  return names_.Add();
+}
+inline void DerivationExpression_ExpressionNamedStruct::add_names(const std::string& value) {
+  names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionNamedStruct.names)
+}
+inline void DerivationExpression_ExpressionNamedStruct::add_names(std::string&& value) {
+  names_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionNamedStruct.names)
+}
+inline void DerivationExpression_ExpressionNamedStruct::add_names(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:substrait.DerivationExpression.ExpressionNamedStruct.names)
+}
+inline void DerivationExpression_ExpressionNamedStruct::add_names(const char* value, size_t size) {
+  names_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:substrait.DerivationExpression.ExpressionNamedStruct.names)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+DerivationExpression_ExpressionNamedStruct::names() const {
+  // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ExpressionNamedStruct.names)
+  return names_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+DerivationExpression_ExpressionNamedStruct::mutable_names() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.DerivationExpression.ExpressionNamedStruct.names)
+  return &names_;
+}
+
+// .substrait.DerivationExpression.ExpressionStruct struct = 2;
+inline bool DerivationExpression_ExpressionNamedStruct::_internal_has_struct_() const {
+  return this != internal_default_instance() && struct__ != nullptr;
+}
+inline bool DerivationExpression_ExpressionNamedStruct::has_struct_() const {
+  return _internal_has_struct_();
+}
+inline void DerivationExpression_ExpressionNamedStruct::clear_struct_() {
+  if (GetArenaForAllocation() == nullptr && struct__ != nullptr) {
+    delete struct__;
+  }
+  struct__ = nullptr;
+}
+inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::_internal_struct_() const {
+  const ::substrait::DerivationExpression_ExpressionStruct* p = struct__;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression_ExpressionStruct&>(
+      ::substrait::_DerivationExpression_ExpressionStruct_default_instance_);
+}
+inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::struct_() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionNamedStruct.struct)
+  return _internal_struct_();
+}
+inline void DerivationExpression_ExpressionNamedStruct::unsafe_arena_set_allocated_struct_(
+    ::substrait::DerivationExpression_ExpressionStruct* struct_) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__);
+  }
+  struct__ = struct_;
+  if (struct_) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionNamedStruct.struct)
+}
+inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::release_struct_() {
+  
+  ::substrait::DerivationExpression_ExpressionStruct* temp = struct__;
+  struct__ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::unsafe_arena_release_struct_() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionNamedStruct.struct)
+  
+  ::substrait::DerivationExpression_ExpressionStruct* temp = struct__;
+  struct__ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::_internal_mutable_struct_() {
+  
+  if (struct__ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression_ExpressionStruct>(GetArenaForAllocation());
+    struct__ = p;
+  }
+  return struct__;
+}
+inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::mutable_struct_() {
+  ::substrait::DerivationExpression_ExpressionStruct* _msg = _internal_mutable_struct_();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionNamedStruct.struct)
+  return _msg;
+}
+inline void DerivationExpression_ExpressionNamedStruct::set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete struct__;
+  }
+  if (struct_) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionStruct>::GetOwningArena(struct_);
+    if (message_arena != submessage_arena) {
+      struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, struct_, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  struct__ = struct_;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionNamedStruct.struct)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression_ExpressionList
+
+// .substrait.DerivationExpression type = 1;
+inline bool DerivationExpression_ExpressionList::_internal_has_type() const {
+  return this != internal_default_instance() && type_ != nullptr;
+}
+inline bool DerivationExpression_ExpressionList::has_type() const {
+  return _internal_has_type();
+}
+inline void DerivationExpression_ExpressionList::clear_type() {
+  if (GetArenaForAllocation() == nullptr && type_ != nullptr) {
+    delete type_;
+  }
+  type_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionList::_internal_type() const {
+  const ::substrait::DerivationExpression* p = type_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionList::type() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.type)
+  return _internal_type();
+}
+inline void DerivationExpression_ExpressionList::unsafe_arena_set_allocated_type(
+    ::substrait::DerivationExpression* type) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_);
+  }
+  type_ = type;
+  if (type) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionList.type)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::release_type() {
+  
+  ::substrait::DerivationExpression* temp = type_;
+  type_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::unsafe_arena_release_type() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionList.type)
+  
+  ::substrait::DerivationExpression* temp = type_;
+  type_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::_internal_mutable_type() {
+  
+  if (type_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    type_ = p;
+  }
+  return type_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::mutable_type() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_type();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionList.type)
+  return _msg;
+}
+inline void DerivationExpression_ExpressionList::set_allocated_type(::substrait::DerivationExpression* type) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete type_;
+  }
+  if (type) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(type);
+    if (message_arena != submessage_arena) {
+      type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, type, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  type_ = type;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionList.type)
+}
+
+// uint32 variation_pointer = 2;
+inline void DerivationExpression_ExpressionList::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t DerivationExpression_ExpressionList::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t DerivationExpression_ExpressionList::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void DerivationExpression_ExpressionList::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void DerivationExpression_ExpressionList::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionList.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 3;
+inline void DerivationExpression_ExpressionList::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionList::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionList::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.nullability)
+  return _internal_nullability();
+}
+inline void DerivationExpression_ExpressionList::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void DerivationExpression_ExpressionList::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionList.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression_ExpressionMap
+
+// .substrait.DerivationExpression key = 1;
+inline bool DerivationExpression_ExpressionMap::_internal_has_key() const {
+  return this != internal_default_instance() && key_ != nullptr;
+}
+inline bool DerivationExpression_ExpressionMap::has_key() const {
+  return _internal_has_key();
+}
+inline void DerivationExpression_ExpressionMap::clear_key() {
+  if (GetArenaForAllocation() == nullptr && key_ != nullptr) {
+    delete key_;
+  }
+  key_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_internal_key() const {
+  const ::substrait::DerivationExpression* p = key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::key() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.key)
+  return _internal_key();
+}
+inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_key(
+    ::substrait::DerivationExpression* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_);
+  }
+  key_ = key;
+  if (key) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionMap.key)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::release_key() {
+  
+  ::substrait::DerivationExpression* temp = key_;
+  key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionMap.key)
+  
+  ::substrait::DerivationExpression* temp = key_;
+  key_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_key() {
+  
+  if (key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    key_ = p;
+  }
+  return key_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_key() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionMap.key)
+  return _msg;
+}
+inline void DerivationExpression_ExpressionMap::set_allocated_key(::substrait::DerivationExpression* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete key_;
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(key);
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionMap.key)
+}
+
+// .substrait.DerivationExpression value = 2;
+inline bool DerivationExpression_ExpressionMap::_internal_has_value() const {
+  return this != internal_default_instance() && value_ != nullptr;
+}
+inline bool DerivationExpression_ExpressionMap::has_value() const {
+  return _internal_has_value();
+}
+inline void DerivationExpression_ExpressionMap::clear_value() {
+  if (GetArenaForAllocation() == nullptr && value_ != nullptr) {
+    delete value_;
+  }
+  value_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_internal_value() const {
+  const ::substrait::DerivationExpression* p = value_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::value() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.value)
+  return _internal_value();
+}
+inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_value(
+    ::substrait::DerivationExpression* value) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
+  }
+  value_ = value;
+  if (value) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionMap.value)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::release_value() {
+  
+  ::substrait::DerivationExpression* temp = value_;
+  value_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionMap.value)
+  
+  ::substrait::DerivationExpression* temp = value_;
+  value_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_value() {
+  
+  if (value_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    value_ = p;
+  }
+  return value_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_value() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionMap.value)
+  return _msg;
+}
+inline void DerivationExpression_ExpressionMap::set_allocated_value(::substrait::DerivationExpression* value) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete value_;
+  }
+  if (value) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(value);
+    if (message_arena != submessage_arena) {
+      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  value_ = value;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionMap.value)
+}
+
+// uint32 variation_pointer = 3;
+inline void DerivationExpression_ExpressionMap::clear_variation_pointer() {
+  variation_pointer_ = 0u;
+}
+inline uint32_t DerivationExpression_ExpressionMap::_internal_variation_pointer() const {
+  return variation_pointer_;
+}
+inline uint32_t DerivationExpression_ExpressionMap::variation_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.variation_pointer)
+  return _internal_variation_pointer();
+}
+inline void DerivationExpression_ExpressionMap::_internal_set_variation_pointer(uint32_t value) {
+  
+  variation_pointer_ = value;
+}
+inline void DerivationExpression_ExpressionMap::set_variation_pointer(uint32_t value) {
+  _internal_set_variation_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionMap.variation_pointer)
+}
+
+// .substrait.Type.Nullability nullability = 4;
+inline void DerivationExpression_ExpressionMap::clear_nullability() {
+  nullability_ = 0;
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionMap::_internal_nullability() const {
+  return static_cast< ::substrait::Type_Nullability >(nullability_);
+}
+inline ::substrait::Type_Nullability DerivationExpression_ExpressionMap::nullability() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.nullability)
+  return _internal_nullability();
+}
+inline void DerivationExpression_ExpressionMap::_internal_set_nullability(::substrait::Type_Nullability value) {
+  
+  nullability_ = value;
+}
+inline void DerivationExpression_ExpressionMap::set_nullability(::substrait::Type_Nullability value) {
+  _internal_set_nullability(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionMap.nullability)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression_IfElse
+
+// .substrait.DerivationExpression if_condition = 1;
+inline bool DerivationExpression_IfElse::_internal_has_if_condition() const {
+  return this != internal_default_instance() && if_condition_ != nullptr;
+}
+inline bool DerivationExpression_IfElse::has_if_condition() const {
+  return _internal_has_if_condition();
+}
+inline void DerivationExpression_IfElse::clear_if_condition() {
+  if (GetArenaForAllocation() == nullptr && if_condition_ != nullptr) {
+    delete if_condition_;
+  }
+  if_condition_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_if_condition() const {
+  const ::substrait::DerivationExpression* p = if_condition_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::if_condition() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.IfElse.if_condition)
+  return _internal_if_condition();
+}
+inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_condition(
+    ::substrait::DerivationExpression* if_condition) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if_condition_);
+  }
+  if_condition_ = if_condition;
+  if (if_condition) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.IfElse.if_condition)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_if_condition() {
+  
+  ::substrait::DerivationExpression* temp = if_condition_;
+  if_condition_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_condition() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.IfElse.if_condition)
+  
+  ::substrait::DerivationExpression* temp = if_condition_;
+  if_condition_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_condition() {
+  
+  if (if_condition_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    if_condition_ = p;
+  }
+  return if_condition_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_condition() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_if_condition();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.if_condition)
+  return _msg;
+}
+inline void DerivationExpression_IfElse::set_allocated_if_condition(::substrait::DerivationExpression* if_condition) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete if_condition_;
+  }
+  if (if_condition) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(if_condition);
+    if (message_arena != submessage_arena) {
+      if_condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, if_condition, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  if_condition_ = if_condition;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.IfElse.if_condition)
+}
+
+// .substrait.DerivationExpression if_return = 2;
+inline bool DerivationExpression_IfElse::_internal_has_if_return() const {
+  return this != internal_default_instance() && if_return_ != nullptr;
+}
+inline bool DerivationExpression_IfElse::has_if_return() const {
+  return _internal_has_if_return();
+}
+inline void DerivationExpression_IfElse::clear_if_return() {
+  if (GetArenaForAllocation() == nullptr && if_return_ != nullptr) {
+    delete if_return_;
+  }
+  if_return_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_if_return() const {
+  const ::substrait::DerivationExpression* p = if_return_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::if_return() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.IfElse.if_return)
+  return _internal_if_return();
+}
+inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_return(
+    ::substrait::DerivationExpression* if_return) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if_return_);
+  }
+  if_return_ = if_return;
+  if (if_return) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.IfElse.if_return)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_if_return() {
+  
+  ::substrait::DerivationExpression* temp = if_return_;
+  if_return_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_return() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.IfElse.if_return)
+  
+  ::substrait::DerivationExpression* temp = if_return_;
+  if_return_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_return() {
+  
+  if (if_return_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    if_return_ = p;
+  }
+  return if_return_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_return() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_if_return();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.if_return)
+  return _msg;
+}
+inline void DerivationExpression_IfElse::set_allocated_if_return(::substrait::DerivationExpression* if_return) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete if_return_;
+  }
+  if (if_return) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(if_return);
+    if (message_arena != submessage_arena) {
+      if_return = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, if_return, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  if_return_ = if_return;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.IfElse.if_return)
+}
+
+// .substrait.DerivationExpression else_return = 3;
+inline bool DerivationExpression_IfElse::_internal_has_else_return() const {
+  return this != internal_default_instance() && else_return_ != nullptr;
+}
+inline bool DerivationExpression_IfElse::has_else_return() const {
+  return _internal_has_else_return();
+}
+inline void DerivationExpression_IfElse::clear_else_return() {
+  if (GetArenaForAllocation() == nullptr && else_return_ != nullptr) {
+    delete else_return_;
+  }
+  else_return_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_else_return() const {
+  const ::substrait::DerivationExpression* p = else_return_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::else_return() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.IfElse.else_return)
+  return _internal_else_return();
+}
+inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_else_return(
+    ::substrait::DerivationExpression* else_return) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else_return_);
+  }
+  else_return_ = else_return;
+  if (else_return) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.IfElse.else_return)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_else_return() {
+  
+  ::substrait::DerivationExpression* temp = else_return_;
+  else_return_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_else_return() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.IfElse.else_return)
+  
+  ::substrait::DerivationExpression* temp = else_return_;
+  else_return_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_else_return() {
+  
+  if (else_return_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    else_return_ = p;
+  }
+  return else_return_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_else_return() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_else_return();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.else_return)
+  return _msg;
+}
+inline void DerivationExpression_IfElse::set_allocated_else_return(::substrait::DerivationExpression* else_return) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete else_return_;
+  }
+  if (else_return) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(else_return);
+    if (message_arena != submessage_arena) {
+      else_return = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, else_return, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  else_return_ = else_return;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.IfElse.else_return)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression_UnaryOp
+
+// .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1;
+inline void DerivationExpression_UnaryOp::clear_op_type() {
+  op_type_ = 0;
+}
+inline ::substrait::DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::_internal_op_type() const {
+  return static_cast< ::substrait::DerivationExpression_UnaryOp_UnaryOpType >(op_type_);
+}
+inline ::substrait::DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::op_type() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.UnaryOp.op_type)
+  return _internal_op_type();
+}
+inline void DerivationExpression_UnaryOp::_internal_set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value) {
+  
+  op_type_ = value;
+}
+inline void DerivationExpression_UnaryOp::set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value) {
+  _internal_set_op_type(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.UnaryOp.op_type)
+}
+
+// .substrait.DerivationExpression arg = 2;
+inline bool DerivationExpression_UnaryOp::_internal_has_arg() const {
+  return this != internal_default_instance() && arg_ != nullptr;
+}
+inline bool DerivationExpression_UnaryOp::has_arg() const {
+  return _internal_has_arg();
+}
+inline void DerivationExpression_UnaryOp::clear_arg() {
+  if (GetArenaForAllocation() == nullptr && arg_ != nullptr) {
+    delete arg_;
+  }
+  arg_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_UnaryOp::_internal_arg() const {
+  const ::substrait::DerivationExpression* p = arg_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_UnaryOp::arg() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.UnaryOp.arg)
+  return _internal_arg();
+}
+inline void DerivationExpression_UnaryOp::unsafe_arena_set_allocated_arg(
+    ::substrait::DerivationExpression* arg) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_);
+  }
+  arg_ = arg;
+  if (arg) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.UnaryOp.arg)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::release_arg() {
+  
+  ::substrait::DerivationExpression* temp = arg_;
+  arg_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::unsafe_arena_release_arg() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.UnaryOp.arg)
+  
+  ::substrait::DerivationExpression* temp = arg_;
+  arg_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::_internal_mutable_arg() {
+  
+  if (arg_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    arg_ = p;
+  }
+  return arg_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::mutable_arg() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_arg();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.UnaryOp.arg)
+  return _msg;
+}
+inline void DerivationExpression_UnaryOp::set_allocated_arg(::substrait::DerivationExpression* arg) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete arg_;
+  }
+  if (arg) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(arg);
+    if (message_arena != submessage_arena) {
+      arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, arg, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  arg_ = arg;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.UnaryOp.arg)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression_BinaryOp
+
+// .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1;
+inline void DerivationExpression_BinaryOp::clear_op_type() {
+  op_type_ = 0;
+}
+inline ::substrait::DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::_internal_op_type() const {
+  return static_cast< ::substrait::DerivationExpression_BinaryOp_BinaryOpType >(op_type_);
+}
+inline ::substrait::DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::op_type() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.BinaryOp.op_type)
+  return _internal_op_type();
+}
+inline void DerivationExpression_BinaryOp::_internal_set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value) {
+  
+  op_type_ = value;
+}
+inline void DerivationExpression_BinaryOp::set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value) {
+  _internal_set_op_type(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.BinaryOp.op_type)
+}
+
+// .substrait.DerivationExpression arg1 = 2;
+inline bool DerivationExpression_BinaryOp::_internal_has_arg1() const {
+  return this != internal_default_instance() && arg1_ != nullptr;
+}
+inline bool DerivationExpression_BinaryOp::has_arg1() const {
+  return _internal_has_arg1();
+}
+inline void DerivationExpression_BinaryOp::clear_arg1() {
+  if (GetArenaForAllocation() == nullptr && arg1_ != nullptr) {
+    delete arg1_;
+  }
+  arg1_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::_internal_arg1() const {
+  const ::substrait::DerivationExpression* p = arg1_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::arg1() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.BinaryOp.arg1)
+  return _internal_arg1();
+}
+inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg1(
+    ::substrait::DerivationExpression* arg1) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg1_);
+  }
+  arg1_ = arg1;
+  if (arg1) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.BinaryOp.arg1)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::release_arg1() {
+  
+  ::substrait::DerivationExpression* temp = arg1_;
+  arg1_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg1() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.BinaryOp.arg1)
+  
+  ::substrait::DerivationExpression* temp = arg1_;
+  arg1_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg1() {
+  
+  if (arg1_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    arg1_ = p;
+  }
+  return arg1_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg1() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_arg1();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.BinaryOp.arg1)
+  return _msg;
+}
+inline void DerivationExpression_BinaryOp::set_allocated_arg1(::substrait::DerivationExpression* arg1) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete arg1_;
+  }
+  if (arg1) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(arg1);
+    if (message_arena != submessage_arena) {
+      arg1 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, arg1, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  arg1_ = arg1;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.BinaryOp.arg1)
+}
+
+// .substrait.DerivationExpression arg2 = 3;
+inline bool DerivationExpression_BinaryOp::_internal_has_arg2() const {
+  return this != internal_default_instance() && arg2_ != nullptr;
+}
+inline bool DerivationExpression_BinaryOp::has_arg2() const {
+  return _internal_has_arg2();
+}
+inline void DerivationExpression_BinaryOp::clear_arg2() {
+  if (GetArenaForAllocation() == nullptr && arg2_ != nullptr) {
+    delete arg2_;
+  }
+  arg2_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::_internal_arg2() const {
+  const ::substrait::DerivationExpression* p = arg2_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::arg2() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.BinaryOp.arg2)
+  return _internal_arg2();
+}
+inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg2(
+    ::substrait::DerivationExpression* arg2) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg2_);
+  }
+  arg2_ = arg2;
+  if (arg2) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.BinaryOp.arg2)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::release_arg2() {
+  
+  ::substrait::DerivationExpression* temp = arg2_;
+  arg2_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg2() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.BinaryOp.arg2)
+  
+  ::substrait::DerivationExpression* temp = arg2_;
+  arg2_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg2() {
+  
+  if (arg2_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    arg2_ = p;
+  }
+  return arg2_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg2() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_arg2();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.BinaryOp.arg2)
+  return _msg;
+}
+inline void DerivationExpression_BinaryOp::set_allocated_arg2(::substrait::DerivationExpression* arg2) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete arg2_;
+  }
+  if (arg2) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(arg2);
+    if (message_arena != submessage_arena) {
+      arg2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, arg2, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  arg2_ = arg2;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.BinaryOp.arg2)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression_ReturnProgram_Assignment
+
+// string name = 1;
+inline void DerivationExpression_ReturnProgram_Assignment::clear_name() {
+  name_.ClearToEmpty();
+}
+inline const std::string& DerivationExpression_ReturnProgram_Assignment::name() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.Assignment.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DerivationExpression_ReturnProgram_Assignment::set_name(ArgT0&& arg0, ArgT... args) {
+ 
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ReturnProgram.Assignment.name)
+}
+inline std::string* DerivationExpression_ReturnProgram_Assignment::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.Assignment.name)
+  return _s;
+}
+inline const std::string& DerivationExpression_ReturnProgram_Assignment::_internal_name() const {
+  return name_.Get();
+}
+inline void DerivationExpression_ReturnProgram_Assignment::_internal_set_name(const std::string& value) {
+  
+  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DerivationExpression_ReturnProgram_Assignment::_internal_mutable_name() {
+  
+  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DerivationExpression_ReturnProgram_Assignment::release_name() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.Assignment.name)
+  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.name)
+}
+
+// .substrait.DerivationExpression expression = 2;
+inline bool DerivationExpression_ReturnProgram_Assignment::_internal_has_expression() const {
+  return this != internal_default_instance() && expression_ != nullptr;
+}
+inline bool DerivationExpression_ReturnProgram_Assignment::has_expression() const {
+  return _internal_has_expression();
+}
+inline void DerivationExpression_ReturnProgram_Assignment::clear_expression() {
+  if (GetArenaForAllocation() == nullptr && expression_ != nullptr) {
+    delete expression_;
+  }
+  expression_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::_internal_expression() const {
+  const ::substrait::DerivationExpression* p = expression_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::expression() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.Assignment.expression)
+  return _internal_expression();
+}
+inline void DerivationExpression_ReturnProgram_Assignment::unsafe_arena_set_allocated_expression(
+    ::substrait::DerivationExpression* expression) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_);
+  }
+  expression_ = expression;
+  if (expression) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.expression)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::release_expression() {
+  
+  ::substrait::DerivationExpression* temp = expression_;
+  expression_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::unsafe_arena_release_expression() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.Assignment.expression)
+  
+  ::substrait::DerivationExpression* temp = expression_;
+  expression_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::_internal_mutable_expression() {
+  
+  if (expression_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    expression_ = p;
+  }
+  return expression_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::mutable_expression() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_expression();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.Assignment.expression)
+  return _msg;
+}
+inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_expression(::substrait::DerivationExpression* expression) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete expression_;
+  }
+  if (expression) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(expression);
+    if (message_arena != submessage_arena) {
+      expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, expression, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  expression_ = expression;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.expression)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression_ReturnProgram
+
+// repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1;
+inline int DerivationExpression_ReturnProgram::_internal_assignments_size() const {
+  return assignments_.size();
+}
+inline int DerivationExpression_ReturnProgram::assignments_size() const {
+  return _internal_assignments_size();
+}
+inline void DerivationExpression_ReturnProgram::clear_assignments() {
+  assignments_.Clear();
+}
+inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::mutable_assignments(int index) {
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.assignments)
+  return assignments_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >*
+DerivationExpression_ReturnProgram::mutable_assignments() {
+  // @@protoc_insertion_point(field_mutable_list:substrait.DerivationExpression.ReturnProgram.assignments)
+  return &assignments_;
+}
+inline const ::substrait::DerivationExpression_ReturnProgram_Assignment& DerivationExpression_ReturnProgram::_internal_assignments(int index) const {
+  return assignments_.Get(index);
+}
+inline const ::substrait::DerivationExpression_ReturnProgram_Assignment& DerivationExpression_ReturnProgram::assignments(int index) const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.assignments)
+  return _internal_assignments(index);
+}
+inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::_internal_add_assignments() {
+  return assignments_.Add();
+}
+inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::add_assignments() {
+  ::substrait::DerivationExpression_ReturnProgram_Assignment* _add = _internal_add_assignments();
+  // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ReturnProgram.assignments)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >&
+DerivationExpression_ReturnProgram::assignments() const {
+  // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ReturnProgram.assignments)
+  return assignments_;
+}
+
+// .substrait.DerivationExpression final_expression = 2;
+inline bool DerivationExpression_ReturnProgram::_internal_has_final_expression() const {
+  return this != internal_default_instance() && final_expression_ != nullptr;
+}
+inline bool DerivationExpression_ReturnProgram::has_final_expression() const {
+  return _internal_has_final_expression();
+}
+inline void DerivationExpression_ReturnProgram::clear_final_expression() {
+  if (GetArenaForAllocation() == nullptr && final_expression_ != nullptr) {
+    delete final_expression_;
+  }
+  final_expression_ = nullptr;
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram::_internal_final_expression() const {
+  const ::substrait::DerivationExpression* p = final_expression_;
+  return p != nullptr ? *p : reinterpret_cast<const ::substrait::DerivationExpression&>(
+      ::substrait::_DerivationExpression_default_instance_);
+}
+inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram::final_expression() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.final_expression)
+  return _internal_final_expression();
+}
+inline void DerivationExpression_ReturnProgram::unsafe_arena_set_allocated_final_expression(
+    ::substrait::DerivationExpression* final_expression) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(final_expression_);
+  }
+  final_expression_ = final_expression;
+  if (final_expression) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ReturnProgram.final_expression)
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::release_final_expression() {
+  
+  ::substrait::DerivationExpression* temp = final_expression_;
+  final_expression_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::unsafe_arena_release_final_expression() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.final_expression)
+  
+  ::substrait::DerivationExpression* temp = final_expression_;
+  final_expression_ = nullptr;
+  return temp;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::_internal_mutable_final_expression() {
+  
+  if (final_expression_ == nullptr) {
+    auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation());
+    final_expression_ = p;
+  }
+  return final_expression_;
+}
+inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::mutable_final_expression() {
+  ::substrait::DerivationExpression* _msg = _internal_mutable_final_expression();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.final_expression)
+  return _msg;
+}
+inline void DerivationExpression_ReturnProgram::set_allocated_final_expression(::substrait::DerivationExpression* final_expression) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete final_expression_;
+  }
+  if (final_expression) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(final_expression);
+    if (message_arena != submessage_arena) {
+      final_expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, final_expression, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  final_expression_ = final_expression;
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.final_expression)
+}
+
+// -------------------------------------------------------------------
+
+// DerivationExpression
+
+// .substrait.Type.Boolean bool = 1;
+inline bool DerivationExpression::_internal_has_bool_() const {
+  return kind_case() == kBool;
+}
+inline bool DerivationExpression::has_bool_() const {
+  return _internal_has_bool_();
+}
+inline void DerivationExpression::set_has_bool_() {
+  _oneof_case_[0] = kBool;
+}
+inline ::substrait::Type_Boolean* DerivationExpression::release_bool_() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.bool)
+  if (_internal_has_bool_()) {
+    clear_has_kind();
+      ::substrait::Type_Boolean* temp = kind_.bool__;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.bool__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Boolean& DerivationExpression::_internal_bool_() const {
+  return _internal_has_bool_()
+      ? *kind_.bool__
+      : reinterpret_cast< ::substrait::Type_Boolean&>(::substrait::_Type_Boolean_default_instance_);
+}
+inline const ::substrait::Type_Boolean& DerivationExpression::bool_() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.bool)
+  return _internal_bool_();
+}
+inline ::substrait::Type_Boolean* DerivationExpression::unsafe_arena_release_bool_() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.bool)
+  if (_internal_has_bool_()) {
+    clear_has_kind();
+    ::substrait::Type_Boolean* temp = kind_.bool__;
+    kind_.bool__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_bool_(::substrait::Type_Boolean* bool_) {
+  clear_kind();
+  if (bool_) {
+    set_has_bool_();
+    kind_.bool__ = bool_;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.bool)
+}
+inline ::substrait::Type_Boolean* DerivationExpression::_internal_mutable_bool_() {
+  if (!_internal_has_bool_()) {
+    clear_kind();
+    set_has_bool_();
+    kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArenaForAllocation());
+  }
+  return kind_.bool__;
+}
+inline ::substrait::Type_Boolean* DerivationExpression::mutable_bool_() {
+  ::substrait::Type_Boolean* _msg = _internal_mutable_bool_();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.bool)
+  return _msg;
+}
+
+// .substrait.Type.I8 i8 = 2;
+inline bool DerivationExpression::_internal_has_i8() const {
+  return kind_case() == kI8;
+}
+inline bool DerivationExpression::has_i8() const {
+  return _internal_has_i8();
+}
+inline void DerivationExpression::set_has_i8() {
+  _oneof_case_[0] = kI8;
+}
+inline ::substrait::Type_I8* DerivationExpression::release_i8() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i8)
+  if (_internal_has_i8()) {
+    clear_has_kind();
+      ::substrait::Type_I8* temp = kind_.i8_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.i8_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_I8& DerivationExpression::_internal_i8() const {
+  return _internal_has_i8()
+      ? *kind_.i8_
+      : reinterpret_cast< ::substrait::Type_I8&>(::substrait::_Type_I8_default_instance_);
+}
+inline const ::substrait::Type_I8& DerivationExpression::i8() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i8)
+  return _internal_i8();
+}
+inline ::substrait::Type_I8* DerivationExpression::unsafe_arena_release_i8() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i8)
+  if (_internal_has_i8()) {
+    clear_has_kind();
+    ::substrait::Type_I8* temp = kind_.i8_;
+    kind_.i8_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_i8(::substrait::Type_I8* i8) {
+  clear_kind();
+  if (i8) {
+    set_has_i8();
+    kind_.i8_ = i8;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i8)
+}
+inline ::substrait::Type_I8* DerivationExpression::_internal_mutable_i8() {
+  if (!_internal_has_i8()) {
+    clear_kind();
+    set_has_i8();
+    kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArenaForAllocation());
+  }
+  return kind_.i8_;
+}
+inline ::substrait::Type_I8* DerivationExpression::mutable_i8() {
+  ::substrait::Type_I8* _msg = _internal_mutable_i8();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i8)
+  return _msg;
+}
+
+// .substrait.Type.I16 i16 = 3;
+inline bool DerivationExpression::_internal_has_i16() const {
+  return kind_case() == kI16;
+}
+inline bool DerivationExpression::has_i16() const {
+  return _internal_has_i16();
+}
+inline void DerivationExpression::set_has_i16() {
+  _oneof_case_[0] = kI16;
+}
+inline ::substrait::Type_I16* DerivationExpression::release_i16() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i16)
+  if (_internal_has_i16()) {
+    clear_has_kind();
+      ::substrait::Type_I16* temp = kind_.i16_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.i16_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_I16& DerivationExpression::_internal_i16() const {
+  return _internal_has_i16()
+      ? *kind_.i16_
+      : reinterpret_cast< ::substrait::Type_I16&>(::substrait::_Type_I16_default_instance_);
+}
+inline const ::substrait::Type_I16& DerivationExpression::i16() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i16)
+  return _internal_i16();
+}
+inline ::substrait::Type_I16* DerivationExpression::unsafe_arena_release_i16() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i16)
+  if (_internal_has_i16()) {
+    clear_has_kind();
+    ::substrait::Type_I16* temp = kind_.i16_;
+    kind_.i16_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_i16(::substrait::Type_I16* i16) {
+  clear_kind();
+  if (i16) {
+    set_has_i16();
+    kind_.i16_ = i16;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i16)
+}
+inline ::substrait::Type_I16* DerivationExpression::_internal_mutable_i16() {
+  if (!_internal_has_i16()) {
+    clear_kind();
+    set_has_i16();
+    kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArenaForAllocation());
+  }
+  return kind_.i16_;
+}
+inline ::substrait::Type_I16* DerivationExpression::mutable_i16() {
+  ::substrait::Type_I16* _msg = _internal_mutable_i16();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i16)
+  return _msg;
+}
+
+// .substrait.Type.I32 i32 = 5;
+inline bool DerivationExpression::_internal_has_i32() const {
+  return kind_case() == kI32;
+}
+inline bool DerivationExpression::has_i32() const {
+  return _internal_has_i32();
+}
+inline void DerivationExpression::set_has_i32() {
+  _oneof_case_[0] = kI32;
+}
+inline ::substrait::Type_I32* DerivationExpression::release_i32() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i32)
+  if (_internal_has_i32()) {
+    clear_has_kind();
+      ::substrait::Type_I32* temp = kind_.i32_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.i32_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_I32& DerivationExpression::_internal_i32() const {
+  return _internal_has_i32()
+      ? *kind_.i32_
+      : reinterpret_cast< ::substrait::Type_I32&>(::substrait::_Type_I32_default_instance_);
+}
+inline const ::substrait::Type_I32& DerivationExpression::i32() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i32)
+  return _internal_i32();
+}
+inline ::substrait::Type_I32* DerivationExpression::unsafe_arena_release_i32() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i32)
+  if (_internal_has_i32()) {
+    clear_has_kind();
+    ::substrait::Type_I32* temp = kind_.i32_;
+    kind_.i32_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_i32(::substrait::Type_I32* i32) {
+  clear_kind();
+  if (i32) {
+    set_has_i32();
+    kind_.i32_ = i32;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i32)
+}
+inline ::substrait::Type_I32* DerivationExpression::_internal_mutable_i32() {
+  if (!_internal_has_i32()) {
+    clear_kind();
+    set_has_i32();
+    kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArenaForAllocation());
+  }
+  return kind_.i32_;
+}
+inline ::substrait::Type_I32* DerivationExpression::mutable_i32() {
+  ::substrait::Type_I32* _msg = _internal_mutable_i32();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i32)
+  return _msg;
+}
+
+// .substrait.Type.I64 i64 = 7;
+inline bool DerivationExpression::_internal_has_i64() const {
+  return kind_case() == kI64;
+}
+inline bool DerivationExpression::has_i64() const {
+  return _internal_has_i64();
+}
+inline void DerivationExpression::set_has_i64() {
+  _oneof_case_[0] = kI64;
+}
+inline ::substrait::Type_I64* DerivationExpression::release_i64() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i64)
+  if (_internal_has_i64()) {
+    clear_has_kind();
+      ::substrait::Type_I64* temp = kind_.i64_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.i64_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_I64& DerivationExpression::_internal_i64() const {
+  return _internal_has_i64()
+      ? *kind_.i64_
+      : reinterpret_cast< ::substrait::Type_I64&>(::substrait::_Type_I64_default_instance_);
+}
+inline const ::substrait::Type_I64& DerivationExpression::i64() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i64)
+  return _internal_i64();
+}
+inline ::substrait::Type_I64* DerivationExpression::unsafe_arena_release_i64() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i64)
+  if (_internal_has_i64()) {
+    clear_has_kind();
+    ::substrait::Type_I64* temp = kind_.i64_;
+    kind_.i64_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_i64(::substrait::Type_I64* i64) {
+  clear_kind();
+  if (i64) {
+    set_has_i64();
+    kind_.i64_ = i64;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i64)
+}
+inline ::substrait::Type_I64* DerivationExpression::_internal_mutable_i64() {
+  if (!_internal_has_i64()) {
+    clear_kind();
+    set_has_i64();
+    kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArenaForAllocation());
+  }
+  return kind_.i64_;
+}
+inline ::substrait::Type_I64* DerivationExpression::mutable_i64() {
+  ::substrait::Type_I64* _msg = _internal_mutable_i64();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i64)
+  return _msg;
+}
+
+// .substrait.Type.FP32 fp32 = 10;
+inline bool DerivationExpression::_internal_has_fp32() const {
+  return kind_case() == kFp32;
+}
+inline bool DerivationExpression::has_fp32() const {
+  return _internal_has_fp32();
+}
+inline void DerivationExpression::set_has_fp32() {
+  _oneof_case_[0] = kFp32;
+}
+inline ::substrait::Type_FP32* DerivationExpression::release_fp32() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fp32)
+  if (_internal_has_fp32()) {
+    clear_has_kind();
+      ::substrait::Type_FP32* temp = kind_.fp32_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.fp32_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_FP32& DerivationExpression::_internal_fp32() const {
+  return _internal_has_fp32()
+      ? *kind_.fp32_
+      : reinterpret_cast< ::substrait::Type_FP32&>(::substrait::_Type_FP32_default_instance_);
+}
+inline const ::substrait::Type_FP32& DerivationExpression::fp32() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fp32)
+  return _internal_fp32();
+}
+inline ::substrait::Type_FP32* DerivationExpression::unsafe_arena_release_fp32() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fp32)
+  if (_internal_has_fp32()) {
+    clear_has_kind();
+    ::substrait::Type_FP32* temp = kind_.fp32_;
+    kind_.fp32_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_fp32(::substrait::Type_FP32* fp32) {
+  clear_kind();
+  if (fp32) {
+    set_has_fp32();
+    kind_.fp32_ = fp32;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fp32)
+}
+inline ::substrait::Type_FP32* DerivationExpression::_internal_mutable_fp32() {
+  if (!_internal_has_fp32()) {
+    clear_kind();
+    set_has_fp32();
+    kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArenaForAllocation());
+  }
+  return kind_.fp32_;
+}
+inline ::substrait::Type_FP32* DerivationExpression::mutable_fp32() {
+  ::substrait::Type_FP32* _msg = _internal_mutable_fp32();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fp32)
+  return _msg;
+}
+
+// .substrait.Type.FP64 fp64 = 11;
+inline bool DerivationExpression::_internal_has_fp64() const {
+  return kind_case() == kFp64;
+}
+inline bool DerivationExpression::has_fp64() const {
+  return _internal_has_fp64();
+}
+inline void DerivationExpression::set_has_fp64() {
+  _oneof_case_[0] = kFp64;
+}
+inline ::substrait::Type_FP64* DerivationExpression::release_fp64() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fp64)
+  if (_internal_has_fp64()) {
+    clear_has_kind();
+      ::substrait::Type_FP64* temp = kind_.fp64_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.fp64_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_FP64& DerivationExpression::_internal_fp64() const {
+  return _internal_has_fp64()
+      ? *kind_.fp64_
+      : reinterpret_cast< ::substrait::Type_FP64&>(::substrait::_Type_FP64_default_instance_);
+}
+inline const ::substrait::Type_FP64& DerivationExpression::fp64() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fp64)
+  return _internal_fp64();
+}
+inline ::substrait::Type_FP64* DerivationExpression::unsafe_arena_release_fp64() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fp64)
+  if (_internal_has_fp64()) {
+    clear_has_kind();
+    ::substrait::Type_FP64* temp = kind_.fp64_;
+    kind_.fp64_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_fp64(::substrait::Type_FP64* fp64) {
+  clear_kind();
+  if (fp64) {
+    set_has_fp64();
+    kind_.fp64_ = fp64;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fp64)
+}
+inline ::substrait::Type_FP64* DerivationExpression::_internal_mutable_fp64() {
+  if (!_internal_has_fp64()) {
+    clear_kind();
+    set_has_fp64();
+    kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArenaForAllocation());
+  }
+  return kind_.fp64_;
+}
+inline ::substrait::Type_FP64* DerivationExpression::mutable_fp64() {
+  ::substrait::Type_FP64* _msg = _internal_mutable_fp64();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fp64)
+  return _msg;
+}
+
+// .substrait.Type.String string = 12;
+inline bool DerivationExpression::_internal_has_string() const {
+  return kind_case() == kString;
+}
+inline bool DerivationExpression::has_string() const {
+  return _internal_has_string();
+}
+inline void DerivationExpression::set_has_string() {
+  _oneof_case_[0] = kString;
+}
+inline ::substrait::Type_String* DerivationExpression::release_string() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.string)
+  if (_internal_has_string()) {
+    clear_has_kind();
+      ::substrait::Type_String* temp = kind_.string_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.string_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_String& DerivationExpression::_internal_string() const {
+  return _internal_has_string()
+      ? *kind_.string_
+      : reinterpret_cast< ::substrait::Type_String&>(::substrait::_Type_String_default_instance_);
+}
+inline const ::substrait::Type_String& DerivationExpression::string() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.string)
+  return _internal_string();
+}
+inline ::substrait::Type_String* DerivationExpression::unsafe_arena_release_string() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.string)
+  if (_internal_has_string()) {
+    clear_has_kind();
+    ::substrait::Type_String* temp = kind_.string_;
+    kind_.string_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_string(::substrait::Type_String* string) {
+  clear_kind();
+  if (string) {
+    set_has_string();
+    kind_.string_ = string;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.string)
+}
+inline ::substrait::Type_String* DerivationExpression::_internal_mutable_string() {
+  if (!_internal_has_string()) {
+    clear_kind();
+    set_has_string();
+    kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArenaForAllocation());
+  }
+  return kind_.string_;
+}
+inline ::substrait::Type_String* DerivationExpression::mutable_string() {
+  ::substrait::Type_String* _msg = _internal_mutable_string();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.string)
+  return _msg;
+}
+
+// .substrait.Type.Binary binary = 13;
+inline bool DerivationExpression::_internal_has_binary() const {
+  return kind_case() == kBinary;
+}
+inline bool DerivationExpression::has_binary() const {
+  return _internal_has_binary();
+}
+inline void DerivationExpression::set_has_binary() {
+  _oneof_case_[0] = kBinary;
+}
+inline ::substrait::Type_Binary* DerivationExpression::release_binary() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.binary)
+  if (_internal_has_binary()) {
+    clear_has_kind();
+      ::substrait::Type_Binary* temp = kind_.binary_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.binary_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Binary& DerivationExpression::_internal_binary() const {
+  return _internal_has_binary()
+      ? *kind_.binary_
+      : reinterpret_cast< ::substrait::Type_Binary&>(::substrait::_Type_Binary_default_instance_);
+}
+inline const ::substrait::Type_Binary& DerivationExpression::binary() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.binary)
+  return _internal_binary();
+}
+inline ::substrait::Type_Binary* DerivationExpression::unsafe_arena_release_binary() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.binary)
+  if (_internal_has_binary()) {
+    clear_has_kind();
+    ::substrait::Type_Binary* temp = kind_.binary_;
+    kind_.binary_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_binary(::substrait::Type_Binary* binary) {
+  clear_kind();
+  if (binary) {
+    set_has_binary();
+    kind_.binary_ = binary;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.binary)
+}
+inline ::substrait::Type_Binary* DerivationExpression::_internal_mutable_binary() {
+  if (!_internal_has_binary()) {
+    clear_kind();
+    set_has_binary();
+    kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArenaForAllocation());
+  }
+  return kind_.binary_;
+}
+inline ::substrait::Type_Binary* DerivationExpression::mutable_binary() {
+  ::substrait::Type_Binary* _msg = _internal_mutable_binary();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.binary)
+  return _msg;
+}
+
+// .substrait.Type.Timestamp timestamp = 14;
+inline bool DerivationExpression::_internal_has_timestamp() const {
+  return kind_case() == kTimestamp;
+}
+inline bool DerivationExpression::has_timestamp() const {
+  return _internal_has_timestamp();
+}
+inline void DerivationExpression::set_has_timestamp() {
+  _oneof_case_[0] = kTimestamp;
+}
+inline ::substrait::Type_Timestamp* DerivationExpression::release_timestamp() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.timestamp)
+  if (_internal_has_timestamp()) {
+    clear_has_kind();
+      ::substrait::Type_Timestamp* temp = kind_.timestamp_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.timestamp_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Timestamp& DerivationExpression::_internal_timestamp() const {
+  return _internal_has_timestamp()
+      ? *kind_.timestamp_
+      : reinterpret_cast< ::substrait::Type_Timestamp&>(::substrait::_Type_Timestamp_default_instance_);
+}
+inline const ::substrait::Type_Timestamp& DerivationExpression::timestamp() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.timestamp)
+  return _internal_timestamp();
+}
+inline ::substrait::Type_Timestamp* DerivationExpression::unsafe_arena_release_timestamp() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.timestamp)
+  if (_internal_has_timestamp()) {
+    clear_has_kind();
+    ::substrait::Type_Timestamp* temp = kind_.timestamp_;
+    kind_.timestamp_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) {
+  clear_kind();
+  if (timestamp) {
+    set_has_timestamp();
+    kind_.timestamp_ = timestamp;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.timestamp)
+}
+inline ::substrait::Type_Timestamp* DerivationExpression::_internal_mutable_timestamp() {
+  if (!_internal_has_timestamp()) {
+    clear_kind();
+    set_has_timestamp();
+    kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArenaForAllocation());
+  }
+  return kind_.timestamp_;
+}
+inline ::substrait::Type_Timestamp* DerivationExpression::mutable_timestamp() {
+  ::substrait::Type_Timestamp* _msg = _internal_mutable_timestamp();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.timestamp)
+  return _msg;
+}
+
+// .substrait.Type.Date date = 16;
+inline bool DerivationExpression::_internal_has_date() const {
+  return kind_case() == kDate;
+}
+inline bool DerivationExpression::has_date() const {
+  return _internal_has_date();
+}
+inline void DerivationExpression::set_has_date() {
+  _oneof_case_[0] = kDate;
+}
+inline ::substrait::Type_Date* DerivationExpression::release_date() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.date)
+  if (_internal_has_date()) {
+    clear_has_kind();
+      ::substrait::Type_Date* temp = kind_.date_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.date_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Date& DerivationExpression::_internal_date() const {
+  return _internal_has_date()
+      ? *kind_.date_
+      : reinterpret_cast< ::substrait::Type_Date&>(::substrait::_Type_Date_default_instance_);
+}
+inline const ::substrait::Type_Date& DerivationExpression::date() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.date)
+  return _internal_date();
+}
+inline ::substrait::Type_Date* DerivationExpression::unsafe_arena_release_date() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.date)
+  if (_internal_has_date()) {
+    clear_has_kind();
+    ::substrait::Type_Date* temp = kind_.date_;
+    kind_.date_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_date(::substrait::Type_Date* date) {
+  clear_kind();
+  if (date) {
+    set_has_date();
+    kind_.date_ = date;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.date)
+}
+inline ::substrait::Type_Date* DerivationExpression::_internal_mutable_date() {
+  if (!_internal_has_date()) {
+    clear_kind();
+    set_has_date();
+    kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArenaForAllocation());
+  }
+  return kind_.date_;
+}
+inline ::substrait::Type_Date* DerivationExpression::mutable_date() {
+  ::substrait::Type_Date* _msg = _internal_mutable_date();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.date)
+  return _msg;
+}
+
+// .substrait.Type.Time time = 17;
+inline bool DerivationExpression::_internal_has_time() const {
+  return kind_case() == kTime;
+}
+inline bool DerivationExpression::has_time() const {
+  return _internal_has_time();
+}
+inline void DerivationExpression::set_has_time() {
+  _oneof_case_[0] = kTime;
+}
+inline ::substrait::Type_Time* DerivationExpression::release_time() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.time)
+  if (_internal_has_time()) {
+    clear_has_kind();
+      ::substrait::Type_Time* temp = kind_.time_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.time_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_Time& DerivationExpression::_internal_time() const {
+  return _internal_has_time()
+      ? *kind_.time_
+      : reinterpret_cast< ::substrait::Type_Time&>(::substrait::_Type_Time_default_instance_);
+}
+inline const ::substrait::Type_Time& DerivationExpression::time() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.time)
+  return _internal_time();
+}
+inline ::substrait::Type_Time* DerivationExpression::unsafe_arena_release_time() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.time)
+  if (_internal_has_time()) {
+    clear_has_kind();
+    ::substrait::Type_Time* temp = kind_.time_;
+    kind_.time_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_time(::substrait::Type_Time* time) {
+  clear_kind();
+  if (time) {
+    set_has_time();
+    kind_.time_ = time;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.time)
+}
+inline ::substrait::Type_Time* DerivationExpression::_internal_mutable_time() {
+  if (!_internal_has_time()) {
+    clear_kind();
+    set_has_time();
+    kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArenaForAllocation());
+  }
+  return kind_.time_;
+}
+inline ::substrait::Type_Time* DerivationExpression::mutable_time() {
+  ::substrait::Type_Time* _msg = _internal_mutable_time();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.time)
+  return _msg;
+}
+
+// .substrait.Type.IntervalYear interval_year = 19;
+inline bool DerivationExpression::_internal_has_interval_year() const {
+  return kind_case() == kIntervalYear;
+}
+inline bool DerivationExpression::has_interval_year() const {
+  return _internal_has_interval_year();
+}
+inline void DerivationExpression::set_has_interval_year() {
+  _oneof_case_[0] = kIntervalYear;
+}
+inline ::substrait::Type_IntervalYear* DerivationExpression::release_interval_year() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.interval_year)
+  if (_internal_has_interval_year()) {
+    clear_has_kind();
+      ::substrait::Type_IntervalYear* temp = kind_.interval_year_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.interval_year_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_IntervalYear& DerivationExpression::_internal_interval_year() const {
+  return _internal_has_interval_year()
+      ? *kind_.interval_year_
+      : reinterpret_cast< ::substrait::Type_IntervalYear&>(::substrait::_Type_IntervalYear_default_instance_);
+}
+inline const ::substrait::Type_IntervalYear& DerivationExpression::interval_year() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.interval_year)
+  return _internal_interval_year();
+}
+inline ::substrait::Type_IntervalYear* DerivationExpression::unsafe_arena_release_interval_year() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.interval_year)
+  if (_internal_has_interval_year()) {
+    clear_has_kind();
+    ::substrait::Type_IntervalYear* temp = kind_.interval_year_;
+    kind_.interval_year_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) {
+  clear_kind();
+  if (interval_year) {
+    set_has_interval_year();
+    kind_.interval_year_ = interval_year;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.interval_year)
+}
+inline ::substrait::Type_IntervalYear* DerivationExpression::_internal_mutable_interval_year() {
+  if (!_internal_has_interval_year()) {
+    clear_kind();
+    set_has_interval_year();
+    kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArenaForAllocation());
+  }
+  return kind_.interval_year_;
+}
+inline ::substrait::Type_IntervalYear* DerivationExpression::mutable_interval_year() {
+  ::substrait::Type_IntervalYear* _msg = _internal_mutable_interval_year();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.interval_year)
+  return _msg;
+}
+
+// .substrait.Type.IntervalDay interval_day = 20;
+inline bool DerivationExpression::_internal_has_interval_day() const {
+  return kind_case() == kIntervalDay;
+}
+inline bool DerivationExpression::has_interval_day() const {
+  return _internal_has_interval_day();
+}
+inline void DerivationExpression::set_has_interval_day() {
+  _oneof_case_[0] = kIntervalDay;
+}
+inline ::substrait::Type_IntervalDay* DerivationExpression::release_interval_day() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.interval_day)
+  if (_internal_has_interval_day()) {
+    clear_has_kind();
+      ::substrait::Type_IntervalDay* temp = kind_.interval_day_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.interval_day_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_IntervalDay& DerivationExpression::_internal_interval_day() const {
+  return _internal_has_interval_day()
+      ? *kind_.interval_day_
+      : reinterpret_cast< ::substrait::Type_IntervalDay&>(::substrait::_Type_IntervalDay_default_instance_);
+}
+inline const ::substrait::Type_IntervalDay& DerivationExpression::interval_day() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.interval_day)
+  return _internal_interval_day();
+}
+inline ::substrait::Type_IntervalDay* DerivationExpression::unsafe_arena_release_interval_day() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.interval_day)
+  if (_internal_has_interval_day()) {
+    clear_has_kind();
+    ::substrait::Type_IntervalDay* temp = kind_.interval_day_;
+    kind_.interval_day_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) {
+  clear_kind();
+  if (interval_day) {
+    set_has_interval_day();
+    kind_.interval_day_ = interval_day;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.interval_day)
+}
+inline ::substrait::Type_IntervalDay* DerivationExpression::_internal_mutable_interval_day() {
+  if (!_internal_has_interval_day()) {
+    clear_kind();
+    set_has_interval_day();
+    kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArenaForAllocation());
+  }
+  return kind_.interval_day_;
+}
+inline ::substrait::Type_IntervalDay* DerivationExpression::mutable_interval_day() {
+  ::substrait::Type_IntervalDay* _msg = _internal_mutable_interval_day();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.interval_day)
+  return _msg;
+}
+
+// .substrait.Type.TimestampTZ timestamp_tz = 29;
+inline bool DerivationExpression::_internal_has_timestamp_tz() const {
+  return kind_case() == kTimestampTz;
+}
+inline bool DerivationExpression::has_timestamp_tz() const {
+  return _internal_has_timestamp_tz();
+}
+inline void DerivationExpression::set_has_timestamp_tz() {
+  _oneof_case_[0] = kTimestampTz;
+}
+inline ::substrait::Type_TimestampTZ* DerivationExpression::release_timestamp_tz() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.timestamp_tz)
+  if (_internal_has_timestamp_tz()) {
+    clear_has_kind();
+      ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.timestamp_tz_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_TimestampTZ& DerivationExpression::_internal_timestamp_tz() const {
+  return _internal_has_timestamp_tz()
+      ? *kind_.timestamp_tz_
+      : reinterpret_cast< ::substrait::Type_TimestampTZ&>(::substrait::_Type_TimestampTZ_default_instance_);
+}
+inline const ::substrait::Type_TimestampTZ& DerivationExpression::timestamp_tz() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.timestamp_tz)
+  return _internal_timestamp_tz();
+}
+inline ::substrait::Type_TimestampTZ* DerivationExpression::unsafe_arena_release_timestamp_tz() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.timestamp_tz)
+  if (_internal_has_timestamp_tz()) {
+    clear_has_kind();
+    ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_;
+    kind_.timestamp_tz_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) {
+  clear_kind();
+  if (timestamp_tz) {
+    set_has_timestamp_tz();
+    kind_.timestamp_tz_ = timestamp_tz;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.timestamp_tz)
+}
+inline ::substrait::Type_TimestampTZ* DerivationExpression::_internal_mutable_timestamp_tz() {
+  if (!_internal_has_timestamp_tz()) {
+    clear_kind();
+    set_has_timestamp_tz();
+    kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArenaForAllocation());
+  }
+  return kind_.timestamp_tz_;
+}
+inline ::substrait::Type_TimestampTZ* DerivationExpression::mutable_timestamp_tz() {
+  ::substrait::Type_TimestampTZ* _msg = _internal_mutable_timestamp_tz();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.timestamp_tz)
+  return _msg;
+}
+
+// .substrait.Type.UUID uuid = 32;
+inline bool DerivationExpression::_internal_has_uuid() const {
+  return kind_case() == kUuid;
+}
+inline bool DerivationExpression::has_uuid() const {
+  return _internal_has_uuid();
+}
+inline void DerivationExpression::set_has_uuid() {
+  _oneof_case_[0] = kUuid;
+}
+inline ::substrait::Type_UUID* DerivationExpression::release_uuid() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.uuid)
+  if (_internal_has_uuid()) {
+    clear_has_kind();
+      ::substrait::Type_UUID* temp = kind_.uuid_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.uuid_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::Type_UUID& DerivationExpression::_internal_uuid() const {
+  return _internal_has_uuid()
+      ? *kind_.uuid_
+      : reinterpret_cast< ::substrait::Type_UUID&>(::substrait::_Type_UUID_default_instance_);
+}
+inline const ::substrait::Type_UUID& DerivationExpression::uuid() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.uuid)
+  return _internal_uuid();
+}
+inline ::substrait::Type_UUID* DerivationExpression::unsafe_arena_release_uuid() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.uuid)
+  if (_internal_has_uuid()) {
+    clear_has_kind();
+    ::substrait::Type_UUID* temp = kind_.uuid_;
+    kind_.uuid_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_uuid(::substrait::Type_UUID* uuid) {
+  clear_kind();
+  if (uuid) {
+    set_has_uuid();
+    kind_.uuid_ = uuid;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.uuid)
+}
+inline ::substrait::Type_UUID* DerivationExpression::_internal_mutable_uuid() {
+  if (!_internal_has_uuid()) {
+    clear_kind();
+    set_has_uuid();
+    kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArenaForAllocation());
+  }
+  return kind_.uuid_;
+}
+inline ::substrait::Type_UUID* DerivationExpression::mutable_uuid() {
+  ::substrait::Type_UUID* _msg = _internal_mutable_uuid();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.uuid)
+  return _msg;
+}
+
+// .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21;
+inline bool DerivationExpression::_internal_has_fixed_char() const {
+  return kind_case() == kFixedChar;
+}
+inline bool DerivationExpression::has_fixed_char() const {
+  return _internal_has_fixed_char();
+}
+inline void DerivationExpression::set_has_fixed_char() {
+  _oneof_case_[0] = kFixedChar;
+}
+inline void DerivationExpression::clear_fixed_char() {
+  if (_internal_has_fixed_char()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.fixed_char_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::release_fixed_char() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fixed_char)
+  if (_internal_has_fixed_char()) {
+    clear_has_kind();
+      ::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.fixed_char_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::_internal_fixed_char() const {
+  return _internal_has_fixed_char()
+      ? *kind_.fixed_char_
+      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionFixedChar&>(::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_);
+}
+inline const ::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::fixed_char() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fixed_char)
+  return _internal_fixed_char();
+}
+inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::unsafe_arena_release_fixed_char() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fixed_char)
+  if (_internal_has_fixed_char()) {
+    clear_has_kind();
+    ::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_;
+    kind_.fixed_char_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) {
+  clear_kind();
+  if (fixed_char) {
+    set_has_fixed_char();
+    kind_.fixed_char_ = fixed_char;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fixed_char)
+}
+inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::_internal_mutable_fixed_char() {
+  if (!_internal_has_fixed_char()) {
+    clear_kind();
+    set_has_fixed_char();
+    kind_.fixed_char_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedChar >(GetArenaForAllocation());
+  }
+  return kind_.fixed_char_;
+}
+inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::mutable_fixed_char() {
+  ::substrait::DerivationExpression_ExpressionFixedChar* _msg = _internal_mutable_fixed_char();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fixed_char)
+  return _msg;
+}
+
+// .substrait.DerivationExpression.ExpressionVarChar varchar = 22;
+inline bool DerivationExpression::_internal_has_varchar() const {
+  return kind_case() == kVarchar;
+}
+inline bool DerivationExpression::has_varchar() const {
+  return _internal_has_varchar();
+}
+inline void DerivationExpression::set_has_varchar() {
+  _oneof_case_[0] = kVarchar;
+}
+inline void DerivationExpression::clear_varchar() {
+  if (_internal_has_varchar()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.varchar_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::release_varchar() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.varchar)
+  if (_internal_has_varchar()) {
+    clear_has_kind();
+      ::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.varchar_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::_internal_varchar() const {
+  return _internal_has_varchar()
+      ? *kind_.varchar_
+      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionVarChar&>(::substrait::_DerivationExpression_ExpressionVarChar_default_instance_);
+}
+inline const ::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::varchar() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.varchar)
+  return _internal_varchar();
+}
+inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::unsafe_arena_release_varchar() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.varchar)
+  if (_internal_has_varchar()) {
+    clear_has_kind();
+    ::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_;
+    kind_.varchar_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar) {
+  clear_kind();
+  if (varchar) {
+    set_has_varchar();
+    kind_.varchar_ = varchar;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.varchar)
+}
+inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::_internal_mutable_varchar() {
+  if (!_internal_has_varchar()) {
+    clear_kind();
+    set_has_varchar();
+    kind_.varchar_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionVarChar >(GetArenaForAllocation());
+  }
+  return kind_.varchar_;
+}
+inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::mutable_varchar() {
+  ::substrait::DerivationExpression_ExpressionVarChar* _msg = _internal_mutable_varchar();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.varchar)
+  return _msg;
+}
+
+// .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23;
+inline bool DerivationExpression::_internal_has_fixed_binary() const {
+  return kind_case() == kFixedBinary;
+}
+inline bool DerivationExpression::has_fixed_binary() const {
+  return _internal_has_fixed_binary();
+}
+inline void DerivationExpression::set_has_fixed_binary() {
+  _oneof_case_[0] = kFixedBinary;
+}
+inline void DerivationExpression::clear_fixed_binary() {
+  if (_internal_has_fixed_binary()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.fixed_binary_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::release_fixed_binary() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fixed_binary)
+  if (_internal_has_fixed_binary()) {
+    clear_has_kind();
+      ::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.fixed_binary_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::_internal_fixed_binary() const {
+  return _internal_has_fixed_binary()
+      ? *kind_.fixed_binary_
+      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionFixedBinary&>(::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_);
+}
+inline const ::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::fixed_binary() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fixed_binary)
+  return _internal_fixed_binary();
+}
+inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::unsafe_arena_release_fixed_binary() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fixed_binary)
+  if (_internal_has_fixed_binary()) {
+    clear_has_kind();
+    ::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_;
+    kind_.fixed_binary_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) {
+  clear_kind();
+  if (fixed_binary) {
+    set_has_fixed_binary();
+    kind_.fixed_binary_ = fixed_binary;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fixed_binary)
+}
+inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::_internal_mutable_fixed_binary() {
+  if (!_internal_has_fixed_binary()) {
+    clear_kind();
+    set_has_fixed_binary();
+    kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedBinary >(GetArenaForAllocation());
+  }
+  return kind_.fixed_binary_;
+}
+inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::mutable_fixed_binary() {
+  ::substrait::DerivationExpression_ExpressionFixedBinary* _msg = _internal_mutable_fixed_binary();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fixed_binary)
+  return _msg;
+}
+
+// .substrait.DerivationExpression.ExpressionDecimal decimal = 24;
+inline bool DerivationExpression::_internal_has_decimal() const {
+  return kind_case() == kDecimal;
+}
+inline bool DerivationExpression::has_decimal() const {
+  return _internal_has_decimal();
+}
+inline void DerivationExpression::set_has_decimal() {
+  _oneof_case_[0] = kDecimal;
+}
+inline void DerivationExpression::clear_decimal() {
+  if (_internal_has_decimal()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.decimal_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::release_decimal() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.decimal)
+  if (_internal_has_decimal()) {
+    clear_has_kind();
+      ::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.decimal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::_internal_decimal() const {
+  return _internal_has_decimal()
+      ? *kind_.decimal_
+      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionDecimal&>(::substrait::_DerivationExpression_ExpressionDecimal_default_instance_);
+}
+inline const ::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::decimal() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.decimal)
+  return _internal_decimal();
+}
+inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::unsafe_arena_release_decimal() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.decimal)
+  if (_internal_has_decimal()) {
+    clear_has_kind();
+    ::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_;
+    kind_.decimal_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal) {
+  clear_kind();
+  if (decimal) {
+    set_has_decimal();
+    kind_.decimal_ = decimal;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.decimal)
+}
+inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::_internal_mutable_decimal() {
+  if (!_internal_has_decimal()) {
+    clear_kind();
+    set_has_decimal();
+    kind_.decimal_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionDecimal >(GetArenaForAllocation());
+  }
+  return kind_.decimal_;
+}
+inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::mutable_decimal() {
+  ::substrait::DerivationExpression_ExpressionDecimal* _msg = _internal_mutable_decimal();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.decimal)
+  return _msg;
+}
+
+// .substrait.DerivationExpression.ExpressionStruct struct = 25;
+inline bool DerivationExpression::_internal_has_struct_() const {
+  return kind_case() == kStruct;
+}
+inline bool DerivationExpression::has_struct_() const {
+  return _internal_has_struct_();
+}
+inline void DerivationExpression::set_has_struct_() {
+  _oneof_case_[0] = kStruct;
+}
+inline void DerivationExpression::clear_struct_() {
+  if (_internal_has_struct_()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.struct__;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::release_struct_() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.struct)
+  if (_internal_has_struct_()) {
+    clear_has_kind();
+      ::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.struct__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::_internal_struct_() const {
+  return _internal_has_struct_()
+      ? *kind_.struct__
+      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionStruct&>(::substrait::_DerivationExpression_ExpressionStruct_default_instance_);
+}
+inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::struct_() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.struct)
+  return _internal_struct_();
+}
+inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::unsafe_arena_release_struct_() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.struct)
+  if (_internal_has_struct_()) {
+    clear_has_kind();
+    ::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__;
+    kind_.struct__ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) {
+  clear_kind();
+  if (struct_) {
+    set_has_struct_();
+    kind_.struct__ = struct_;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.struct)
+}
+inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::_internal_mutable_struct_() {
+  if (!_internal_has_struct_()) {
+    clear_kind();
+    set_has_struct_();
+    kind_.struct__ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionStruct >(GetArenaForAllocation());
+  }
+  return kind_.struct__;
+}
+inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::mutable_struct_() {
+  ::substrait::DerivationExpression_ExpressionStruct* _msg = _internal_mutable_struct_();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.struct)
+  return _msg;
+}
+
+// .substrait.DerivationExpression.ExpressionList list = 27;
+inline bool DerivationExpression::_internal_has_list() const {
+  return kind_case() == kList;
+}
+inline bool DerivationExpression::has_list() const {
+  return _internal_has_list();
+}
+inline void DerivationExpression::set_has_list() {
+  _oneof_case_[0] = kList;
+}
+inline void DerivationExpression::clear_list() {
+  if (_internal_has_list()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.list_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::release_list() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.list)
+  if (_internal_has_list()) {
+    clear_has_kind();
+      ::substrait::DerivationExpression_ExpressionList* temp = kind_.list_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::DerivationExpression_ExpressionList& DerivationExpression::_internal_list() const {
+  return _internal_has_list()
+      ? *kind_.list_
+      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionList&>(::substrait::_DerivationExpression_ExpressionList_default_instance_);
+}
+inline const ::substrait::DerivationExpression_ExpressionList& DerivationExpression::list() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.list)
+  return _internal_list();
+}
+inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::unsafe_arena_release_list() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.list)
+  if (_internal_has_list()) {
+    clear_has_kind();
+    ::substrait::DerivationExpression_ExpressionList* temp = kind_.list_;
+    kind_.list_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_list(::substrait::DerivationExpression_ExpressionList* list) {
+  clear_kind();
+  if (list) {
+    set_has_list();
+    kind_.list_ = list;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.list)
+}
+inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::_internal_mutable_list() {
+  if (!_internal_has_list()) {
+    clear_kind();
+    set_has_list();
+    kind_.list_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionList >(GetArenaForAllocation());
+  }
+  return kind_.list_;
+}
+inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::mutable_list() {
+  ::substrait::DerivationExpression_ExpressionList* _msg = _internal_mutable_list();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.list)
+  return _msg;
+}
+
+// .substrait.DerivationExpression.ExpressionMap map = 28;
+inline bool DerivationExpression::_internal_has_map() const {
+  return kind_case() == kMap;
+}
+inline bool DerivationExpression::has_map() const {
+  return _internal_has_map();
+}
+inline void DerivationExpression::set_has_map() {
+  _oneof_case_[0] = kMap;
+}
+inline void DerivationExpression::clear_map() {
+  if (_internal_has_map()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.map_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::release_map() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.map)
+  if (_internal_has_map()) {
+    clear_has_kind();
+      ::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.map_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::DerivationExpression_ExpressionMap& DerivationExpression::_internal_map() const {
+  return _internal_has_map()
+      ? *kind_.map_
+      : reinterpret_cast< ::substrait::DerivationExpression_ExpressionMap&>(::substrait::_DerivationExpression_ExpressionMap_default_instance_);
+}
+inline const ::substrait::DerivationExpression_ExpressionMap& DerivationExpression::map() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.map)
+  return _internal_map();
+}
+inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::unsafe_arena_release_map() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.map)
+  if (_internal_has_map()) {
+    clear_has_kind();
+    ::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_;
+    kind_.map_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map) {
+  clear_kind();
+  if (map) {
+    set_has_map();
+    kind_.map_ = map;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.map)
+}
+inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::_internal_mutable_map() {
+  if (!_internal_has_map()) {
+    clear_kind();
+    set_has_map();
+    kind_.map_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionMap >(GetArenaForAllocation());
+  }
+  return kind_.map_;
+}
+inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::mutable_map() {
+  ::substrait::DerivationExpression_ExpressionMap* _msg = _internal_mutable_map();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.map)
+  return _msg;
+}
+
+// uint32 user_defined_pointer = 31;
+inline bool DerivationExpression::_internal_has_user_defined_pointer() const {
+  return kind_case() == kUserDefinedPointer;
+}
+inline bool DerivationExpression::has_user_defined_pointer() const {
+  return _internal_has_user_defined_pointer();
+}
+inline void DerivationExpression::set_has_user_defined_pointer() {
+  _oneof_case_[0] = kUserDefinedPointer;
+}
+inline void DerivationExpression::clear_user_defined_pointer() {
+  if (_internal_has_user_defined_pointer()) {
+    kind_.user_defined_pointer_ = 0u;
+    clear_has_kind();
+  }
+}
+inline uint32_t DerivationExpression::_internal_user_defined_pointer() const {
+  if (_internal_has_user_defined_pointer()) {
+    return kind_.user_defined_pointer_;
+  }
+  return 0u;
+}
+inline void DerivationExpression::_internal_set_user_defined_pointer(uint32_t value) {
+  if (!_internal_has_user_defined_pointer()) {
+    clear_kind();
+    set_has_user_defined_pointer();
+  }
+  kind_.user_defined_pointer_ = value;
+}
+inline uint32_t DerivationExpression::user_defined_pointer() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.user_defined_pointer)
+  return _internal_user_defined_pointer();
+}
+inline void DerivationExpression::set_user_defined_pointer(uint32_t value) {
+  _internal_set_user_defined_pointer(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.user_defined_pointer)
+}
+
+// string type_parameter_name = 33;
+inline bool DerivationExpression::_internal_has_type_parameter_name() const {
+  return kind_case() == kTypeParameterName;
+}
+inline bool DerivationExpression::has_type_parameter_name() const {
+  return _internal_has_type_parameter_name();
+}
+inline void DerivationExpression::set_has_type_parameter_name() {
+  _oneof_case_[0] = kTypeParameterName;
+}
+inline void DerivationExpression::clear_type_parameter_name() {
+  if (_internal_has_type_parameter_name()) {
+    kind_.type_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_kind();
+  }
+}
+inline const std::string& DerivationExpression::type_parameter_name() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.type_parameter_name)
+  return _internal_type_parameter_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline void DerivationExpression::set_type_parameter_name(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_type_parameter_name()) {
+    clear_kind();
+    set_has_type_parameter_name();
+    kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.type_parameter_name)
+}
+inline std::string* DerivationExpression::mutable_type_parameter_name() {
+  std::string* _s = _internal_mutable_type_parameter_name();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.type_parameter_name)
+  return _s;
+}
+inline const std::string& DerivationExpression::_internal_type_parameter_name() const {
+  if (_internal_has_type_parameter_name()) {
+    return kind_.type_parameter_name_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void DerivationExpression::_internal_set_type_parameter_name(const std::string& value) {
+  if (!_internal_has_type_parameter_name()) {
+    clear_kind();
+    set_has_type_parameter_name();
+    kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DerivationExpression::_internal_mutable_type_parameter_name() {
+  if (!_internal_has_type_parameter_name()) {
+    clear_kind();
+    set_has_type_parameter_name();
+    kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return kind_.type_parameter_name_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DerivationExpression::release_type_parameter_name() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.type_parameter_name)
+  if (_internal_has_type_parameter_name()) {
+    clear_has_kind();
+    return kind_.type_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::set_allocated_type_parameter_name(std::string* type_parameter_name) {
+  if (has_kind()) {
+    clear_kind();
+  }
+  if (type_parameter_name != nullptr) {
+    set_has_type_parameter_name();
+    kind_.type_parameter_name_.UnsafeSetDefault(type_parameter_name);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(type_parameter_name);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.type_parameter_name)
+}
+
+// string integer_parameter_name = 34;
+inline bool DerivationExpression::_internal_has_integer_parameter_name() const {
+  return kind_case() == kIntegerParameterName;
+}
+inline bool DerivationExpression::has_integer_parameter_name() const {
+  return _internal_has_integer_parameter_name();
+}
+inline void DerivationExpression::set_has_integer_parameter_name() {
+  _oneof_case_[0] = kIntegerParameterName;
+}
+inline void DerivationExpression::clear_integer_parameter_name() {
+  if (_internal_has_integer_parameter_name()) {
+    kind_.integer_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_kind();
+  }
+}
+inline const std::string& DerivationExpression::integer_parameter_name() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.integer_parameter_name)
+  return _internal_integer_parameter_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline void DerivationExpression::set_integer_parameter_name(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_integer_parameter_name()) {
+    clear_kind();
+    set_has_integer_parameter_name();
+    kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.integer_parameter_name)
+}
+inline std::string* DerivationExpression::mutable_integer_parameter_name() {
+  std::string* _s = _internal_mutable_integer_parameter_name();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.integer_parameter_name)
+  return _s;
+}
+inline const std::string& DerivationExpression::_internal_integer_parameter_name() const {
+  if (_internal_has_integer_parameter_name()) {
+    return kind_.integer_parameter_name_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void DerivationExpression::_internal_set_integer_parameter_name(const std::string& value) {
+  if (!_internal_has_integer_parameter_name()) {
+    clear_kind();
+    set_has_integer_parameter_name();
+    kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DerivationExpression::_internal_mutable_integer_parameter_name() {
+  if (!_internal_has_integer_parameter_name()) {
+    clear_kind();
+    set_has_integer_parameter_name();
+    kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return kind_.integer_parameter_name_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DerivationExpression::release_integer_parameter_name() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.integer_parameter_name)
+  if (_internal_has_integer_parameter_name()) {
+    clear_has_kind();
+    return kind_.integer_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::set_allocated_integer_parameter_name(std::string* integer_parameter_name) {
+  if (has_kind()) {
+    clear_kind();
+  }
+  if (integer_parameter_name != nullptr) {
+    set_has_integer_parameter_name();
+    kind_.integer_parameter_name_.UnsafeSetDefault(integer_parameter_name);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(integer_parameter_name);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.integer_parameter_name)
+}
+
+// int32 integer_literal = 35;
+inline bool DerivationExpression::_internal_has_integer_literal() const {
+  return kind_case() == kIntegerLiteral;
+}
+inline bool DerivationExpression::has_integer_literal() const {
+  return _internal_has_integer_literal();
+}
+inline void DerivationExpression::set_has_integer_literal() {
+  _oneof_case_[0] = kIntegerLiteral;
+}
+inline void DerivationExpression::clear_integer_literal() {
+  if (_internal_has_integer_literal()) {
+    kind_.integer_literal_ = 0;
+    clear_has_kind();
+  }
+}
+inline int32_t DerivationExpression::_internal_integer_literal() const {
+  if (_internal_has_integer_literal()) {
+    return kind_.integer_literal_;
+  }
+  return 0;
+}
+inline void DerivationExpression::_internal_set_integer_literal(int32_t value) {
+  if (!_internal_has_integer_literal()) {
+    clear_kind();
+    set_has_integer_literal();
+  }
+  kind_.integer_literal_ = value;
+}
+inline int32_t DerivationExpression::integer_literal() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.integer_literal)
+  return _internal_integer_literal();
+}
+inline void DerivationExpression::set_integer_literal(int32_t value) {
+  _internal_set_integer_literal(value);
+  // @@protoc_insertion_point(field_set:substrait.DerivationExpression.integer_literal)
+}
+
+// .substrait.DerivationExpression.UnaryOp unary_op = 36;
+inline bool DerivationExpression::_internal_has_unary_op() const {
+  return kind_case() == kUnaryOp;
+}
+inline bool DerivationExpression::has_unary_op() const {
+  return _internal_has_unary_op();
+}
+inline void DerivationExpression::set_has_unary_op() {
+  _oneof_case_[0] = kUnaryOp;
+}
+inline void DerivationExpression::clear_unary_op() {
+  if (_internal_has_unary_op()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.unary_op_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::release_unary_op() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.unary_op)
+  if (_internal_has_unary_op()) {
+    clear_has_kind();
+      ::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.unary_op_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::DerivationExpression_UnaryOp& DerivationExpression::_internal_unary_op() const {
+  return _internal_has_unary_op()
+      ? *kind_.unary_op_
+      : reinterpret_cast< ::substrait::DerivationExpression_UnaryOp&>(::substrait::_DerivationExpression_UnaryOp_default_instance_);
+}
+inline const ::substrait::DerivationExpression_UnaryOp& DerivationExpression::unary_op() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.unary_op)
+  return _internal_unary_op();
+}
+inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::unsafe_arena_release_unary_op() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.unary_op)
+  if (_internal_has_unary_op()) {
+    clear_has_kind();
+    ::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_;
+    kind_.unary_op_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op) {
+  clear_kind();
+  if (unary_op) {
+    set_has_unary_op();
+    kind_.unary_op_ = unary_op;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.unary_op)
+}
+inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::_internal_mutable_unary_op() {
+  if (!_internal_has_unary_op()) {
+    clear_kind();
+    set_has_unary_op();
+    kind_.unary_op_ = CreateMaybeMessage< ::substrait::DerivationExpression_UnaryOp >(GetArenaForAllocation());
+  }
+  return kind_.unary_op_;
+}
+inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::mutable_unary_op() {
+  ::substrait::DerivationExpression_UnaryOp* _msg = _internal_mutable_unary_op();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.unary_op)
+  return _msg;
+}
+
+// .substrait.DerivationExpression.BinaryOp binary_op = 37;
+inline bool DerivationExpression::_internal_has_binary_op() const {
+  return kind_case() == kBinaryOp;
+}
+inline bool DerivationExpression::has_binary_op() const {
+  return _internal_has_binary_op();
+}
+inline void DerivationExpression::set_has_binary_op() {
+  _oneof_case_[0] = kBinaryOp;
+}
+inline void DerivationExpression::clear_binary_op() {
+  if (_internal_has_binary_op()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.binary_op_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::release_binary_op() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.binary_op)
+  if (_internal_has_binary_op()) {
+    clear_has_kind();
+      ::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.binary_op_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::DerivationExpression_BinaryOp& DerivationExpression::_internal_binary_op() const {
+  return _internal_has_binary_op()
+      ? *kind_.binary_op_
+      : reinterpret_cast< ::substrait::DerivationExpression_BinaryOp&>(::substrait::_DerivationExpression_BinaryOp_default_instance_);
+}
+inline const ::substrait::DerivationExpression_BinaryOp& DerivationExpression::binary_op() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.binary_op)
+  return _internal_binary_op();
+}
+inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::unsafe_arena_release_binary_op() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.binary_op)
+  if (_internal_has_binary_op()) {
+    clear_has_kind();
+    ::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_;
+    kind_.binary_op_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op) {
+  clear_kind();
+  if (binary_op) {
+    set_has_binary_op();
+    kind_.binary_op_ = binary_op;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.binary_op)
+}
+inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::_internal_mutable_binary_op() {
+  if (!_internal_has_binary_op()) {
+    clear_kind();
+    set_has_binary_op();
+    kind_.binary_op_ = CreateMaybeMessage< ::substrait::DerivationExpression_BinaryOp >(GetArenaForAllocation());
+  }
+  return kind_.binary_op_;
+}
+inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::mutable_binary_op() {
+  ::substrait::DerivationExpression_BinaryOp* _msg = _internal_mutable_binary_op();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.binary_op)
+  return _msg;
+}
+
+// .substrait.DerivationExpression.IfElse if_else = 38;
+inline bool DerivationExpression::_internal_has_if_else() const {
+  return kind_case() == kIfElse;
+}
+inline bool DerivationExpression::has_if_else() const {
+  return _internal_has_if_else();
+}
+inline void DerivationExpression::set_has_if_else() {
+  _oneof_case_[0] = kIfElse;
+}
+inline void DerivationExpression::clear_if_else() {
+  if (_internal_has_if_else()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.if_else_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::DerivationExpression_IfElse* DerivationExpression::release_if_else() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.if_else)
+  if (_internal_has_if_else()) {
+    clear_has_kind();
+      ::substrait::DerivationExpression_IfElse* temp = kind_.if_else_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.if_else_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::DerivationExpression_IfElse& DerivationExpression::_internal_if_else() const {
+  return _internal_has_if_else()
+      ? *kind_.if_else_
+      : reinterpret_cast< ::substrait::DerivationExpression_IfElse&>(::substrait::_DerivationExpression_IfElse_default_instance_);
+}
+inline const ::substrait::DerivationExpression_IfElse& DerivationExpression::if_else() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.if_else)
+  return _internal_if_else();
+}
+inline ::substrait::DerivationExpression_IfElse* DerivationExpression::unsafe_arena_release_if_else() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.if_else)
+  if (_internal_has_if_else()) {
+    clear_has_kind();
+    ::substrait::DerivationExpression_IfElse* temp = kind_.if_else_;
+    kind_.if_else_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else) {
+  clear_kind();
+  if (if_else) {
+    set_has_if_else();
+    kind_.if_else_ = if_else;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.if_else)
+}
+inline ::substrait::DerivationExpression_IfElse* DerivationExpression::_internal_mutable_if_else() {
+  if (!_internal_has_if_else()) {
+    clear_kind();
+    set_has_if_else();
+    kind_.if_else_ = CreateMaybeMessage< ::substrait::DerivationExpression_IfElse >(GetArenaForAllocation());
+  }
+  return kind_.if_else_;
+}
+inline ::substrait::DerivationExpression_IfElse* DerivationExpression::mutable_if_else() {
+  ::substrait::DerivationExpression_IfElse* _msg = _internal_mutable_if_else();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.if_else)
+  return _msg;
+}
+
+// .substrait.DerivationExpression.ReturnProgram return_program = 39;
+inline bool DerivationExpression::_internal_has_return_program() const {
+  return kind_case() == kReturnProgram;
+}
+inline bool DerivationExpression::has_return_program() const {
+  return _internal_has_return_program();
+}
+inline void DerivationExpression::set_has_return_program() {
+  _oneof_case_[0] = kReturnProgram;
+}
+inline void DerivationExpression::clear_return_program() {
+  if (_internal_has_return_program()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete kind_.return_program_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::release_return_program() {
+  // @@protoc_insertion_point(field_release:substrait.DerivationExpression.return_program)
+  if (_internal_has_return_program()) {
+    clear_has_kind();
+      ::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    kind_.return_program_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::substrait::DerivationExpression_ReturnProgram& DerivationExpression::_internal_return_program() const {
+  return _internal_has_return_program()
+      ? *kind_.return_program_
+      : reinterpret_cast< ::substrait::DerivationExpression_ReturnProgram&>(::substrait::_DerivationExpression_ReturnProgram_default_instance_);
+}
+inline const ::substrait::DerivationExpression_ReturnProgram& DerivationExpression::return_program() const {
+  // @@protoc_insertion_point(field_get:substrait.DerivationExpression.return_program)
+  return _internal_return_program();
+}
+inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::unsafe_arena_release_return_program() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.return_program)
+  if (_internal_has_return_program()) {
+    clear_has_kind();
+    ::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_;
+    kind_.return_program_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void DerivationExpression::unsafe_arena_set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program) {
+  clear_kind();
+  if (return_program) {
+    set_has_return_program();
+    kind_.return_program_ = return_program;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.return_program)
+}
+inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::_internal_mutable_return_program() {
+  if (!_internal_has_return_program()) {
+    clear_kind();
+    set_has_return_program();
+    kind_.return_program_ = CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram >(GetArenaForAllocation());
+  }
+  return kind_.return_program_;
+}
+inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::mutable_return_program() {
+  ::substrait::DerivationExpression_ReturnProgram* _msg = _internal_mutable_return_program();
+  // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.return_program)
+  return _msg;
+}
+
+inline bool DerivationExpression::has_kind() const {
+  return kind_case() != KIND_NOT_SET;
+}
+inline void DerivationExpression::clear_has_kind() {
+  _oneof_case_[0] = KIND_NOT_SET;
+}
+inline DerivationExpression::KindCase DerivationExpression::kind_case() const {
+  return DerivationExpression::KindCase(_oneof_case_[0]);
+}
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace substrait
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::substrait::DerivationExpression_UnaryOp_UnaryOpType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::substrait::DerivationExpression_UnaryOp_UnaryOpType>() {
+  return ::substrait::DerivationExpression_UnaryOp_UnaryOpType_descriptor();
+}
+template <> struct is_proto_enum< ::substrait::DerivationExpression_BinaryOp_BinaryOpType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::substrait::DerivationExpression_BinaryOp_BinaryOpType>() {
+  return ::substrait::DerivationExpression_BinaryOp_BinaryOpType_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_5fexpressions_2eproto
diff --git a/dev/archery/archery/cli.py b/dev/archery/archery/cli.py
index d8eeb7bab0eb..dbe0b5c4bda1 100644
--- a/dev/archery/archery/cli.py
+++ b/dev/archery/archery/cli.py
@@ -118,6 +118,12 @@ def _apply_options(cmd, options):
 @cpp_toolchain_options
 @click.option("--build-type", default=None, type=build_type,
               help="CMake's CMAKE_BUILD_TYPE")
+@click.option("--build-static", default=True, type=BOOL,
+              help="Build static libraries")
+@click.option("--build-shared", default=True, type=BOOL,
+              help="Build shared libraries")
+@click.option("--build-unity", default=True, type=BOOL,
+              help="Use CMAKE_UNITY_BUILD")
 @click.option("--warn-level", default="production", type=warn_level_type,
               help="Controls compiler warnings -W(no-)error.")
 @click.option("--use-gold-linker", default=True, type=BOOL,
diff --git a/dev/archery/archery/lang/cpp.py b/dev/archery/archery/lang/cpp.py
index cf25ba871b5d..4ece6ec829b1 100644
--- a/dev/archery/archery/lang/cpp.py
+++ b/dev/archery/archery/lang/cpp.py
@@ -42,7 +42,7 @@ def __init__(self,
                  cc=None, cxx=None, cxx_flags=None,
                  build_type=None, warn_level=None,
                  cpp_package_prefix=None, install_prefix=None, use_conda=None,
-                 build_static=False, build_shared=True, build_unity=True,
+                 build_static=True, build_shared=True, build_unity=True,
                  # tests & examples
                  with_tests=None, with_benchmarks=None, with_examples=None,
                  with_integration=None,
diff --git a/dev/release/rat_exclude_files.txt b/dev/release/rat_exclude_files.txt
index 6229e0aec396..671b11cd3628 100644
--- a/dev/release/rat_exclude_files.txt
+++ b/dev/release/rat_exclude_files.txt
@@ -31,6 +31,7 @@ cpp/src/generated/parquet_constants.cpp
 cpp/src/generated/parquet_constants.h
 cpp/src/generated/parquet_types.cpp
 cpp/src/generated/parquet_types.h
+cpp/src/generated/substrait/*
 cpp/src/plasma/thirdparty/ae/ae.c
 cpp/src/plasma/thirdparty/ae/ae.h
 cpp/src/plasma/thirdparty/ae/ae_epoll.c
diff --git a/format/substrait/extension_types.yaml b/format/substrait/extension_types.yaml
new file mode 100644
index 000000000000..8909ae7372d0
--- /dev/null
+++ b/format/substrait/extension_types.yaml
@@ -0,0 +1,121 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# substrait::{ExtensionTypeVariation, ExtensionType}s
+# for wrapping types which appear in the arrow type system but
+# are not first-class in substrait. These include:
+# - null
+# - unsigned integers
+# - half-precision floating point numbers
+# - 32 bit times and dates
+# - timestamps with units other than microseconds
+# - timestamps with timezones other than UTC
+# - 256 bit decimals
+# - sparse and dense unions
+# - dictionary encoded types
+# - durations
+# - string and binary with 64 bit offsets
+# - list with 64 bit offsets
+# - interval<months: i32>
+# - interval<days: i32, millis: i32>
+# - interval<months: i32, days: i32, nanos: i64>
+# - arrow::ExtensionTypes
+
+# FIXME these extension types are not parameterizable, which means among
+# other things that we can't declare dictionary type here at all since
+# we'd have to declare a different dictionary type for all encoded types
+# (but that is an infinite space). Similarly, do we need to declare a
+# timestamp variation for all possible timezone strings?
+#
+# Ultimately these declarations are a promise which needs to be backed by
+# equivalent serde in c++. For example, consider u8: when serializing to
+# substrait, we need to wrap instances of arrow::uint8 into the type
+# variation listed below. It would be ideal if we could SinglePointOfTruth
+# this correspondence; either generating c++ from the YAML or YAML from the
+# c++.
+#
+# At present (AFAICT) it's not valid to make this user extensible because
+# even if a user adds their custom scalar function to the registry *and*
+# defines the mapping from that scalar function to a substrait::ExtensionFunction
+# the corresponding YAML doesn't exist at any URI and so it can't be used in
+# substrait. Perhaps we could still help that case by providing a tool to
+# generate YAML from functions; that'd simplify the lives of people trying to
+# write arrow::compute::Functions to "define the function and if you want to
+# reference it from substrait generate this YAML and put it at some URI".
+#
+# In any case for the foreseeable future generation would be far too brittle;
+# URIs will not be accessed by anything but humans and the YAML is effectively
+# structured documentation. Thus extenders should pass the URI in the same way
+# they pass a description string; it's opaque to anything in arrow.
+#
+# We'll need a global mapping which contains:
+#  arrow::uint8 <-> {
+#   uri: "https://github.com/apache/arrow/blob//format/substrait/extension_types.yaml",
+#   name: "u8"
+#  }
+#
+# And additionally convenient builders for subsets of that mapping during serde:
+#  arrow::uint8 <-> reference to anchor
+#
+# Worth noting: it's valid to have multiple ExtensionFunctions with the same name,
+# as long as all impls' mangled ("compound") names are unique.
+# Also worth noting: Options may only be enumerations. This will get strange with
+# functions like is_in, where we'll have to require that one argument is a literal
+# list or something.
+
+type_variations:
+  - parent: i8
+    name: u8
+    description: an unsigned 8 bit integer
+    functions: SEPARATE
+  - parent: i16
+    name: u16
+    description: an unsigned 16 bit integer
+    functions: SEPARATE
+  - parent: i32
+    name: u32
+    description: an unsigned 32 bit integer
+    functions: SEPARATE
+  - parent: i32
+    name: u32
+    description: an unsigned 32 bit integer
+    functions: SEPARATE
+  - parent: i64
+    name: u64
+    description: an unsigned 64 bit integer
+    functions: SEPARATE
+
+  - parent: i16
+    name: fp16
+    description: a 16 bit floating point number
+    functions: SEPARATE
+
+types:
+  - name: "null"
+    structure: {}
+  - name: interval_month
+    structure:
+      months: i32
+  - name: interval_day_milli
+    structure:
+      days: i32
+      millis: i32
+  - name: interval_month_day_nano
+    structure:
+      months: i32
+      days: i32
+      nanos: i64
