diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt index fd7027c30eb..c26c6403676 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 a0eb8f0efe6..0dd9b5b9128 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 73cbd884f44..46c9532266d 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 0a43ec18f60..8a7f31041d7 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 00000000000..3ee09e0de3d --- /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 d85e511c1e7..a391dc88724 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 e46cc7a6fe5..838d7b982c9 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 00000000000..1dfaff1b67d --- /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 +#include +#include +#include + +#include +#include +#include +#include + +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> 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 serialized_plan = + std::move(maybe_serialized_plan).ValueOrDie(); + + // Print the received plan to stdout as JSON + arrow::Result 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> consumers; + std::function()> 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 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 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> 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 b984bc10425..e4421345189 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 c31a7b72483..11b6b1630c5 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> Array::View( const std::shared_ptr& out_type) const { ARROW_ASSIGN_OR_RAISE(std::shared_ptr result, diff --git a/cpp/src/arrow/array/array_base.h b/cpp/src/arrow/array/array_base.h index b6b769cf033..c17daad48fa 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 data_; - const uint8_t* null_bitmap_data_; + const uint8_t* null_bitmap_data_ = NULLPTR; /// Protected method for constructors void SetData(const std::shared_ptr& 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 a513bf0f4ab..4b0e0147cea 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& type, std::unique_ptr* out); +inline Result> MakeBuilder( + const std::shared_ptr& type, MemoryPool* pool = default_memory_pool()) { + std::unique_ptr 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& type, std::unique_ptr* out); +inline Result> MakeBuilderExactIndex( + const std::shared_ptr& type, MemoryPool* pool = default_memory_pool()) { + std::unique_ptr 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& const std::shared_ptr& dictionary, std::unique_ptr* out); +inline Result> MakeDictionaryBuilder( + const std::shared_ptr& type, const std::shared_ptr& dictionary, + MemoryPool* pool = default_memory_pool()) { + std::unique_ptr 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 dc38924d932..f8c686d2c81 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(call.options.get()); + return ::arrow::internal::checked_cast(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(call.options.get()); + return ::arrow::internal::checked_cast( + call.options.get()); } /// A helper for unboxing an Expression composed of associative function calls. @@ -281,7 +279,8 @@ inline Result> 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(*call.options).to_type; + const auto& to_type = + ::arrow::internal::checked_cast(*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 c8b96e04696..ebac7a3da2f 100644 --- a/cpp/src/arrow/csv/column_decoder_test.cc +++ b/cpp/src/arrow/csv/column_decoder_test.cc @@ -22,6 +22,7 @@ #include +#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 514b4247316..45e0d682fa9 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::type>( value)) {} + // Cast from subtypes of Array or Scalar to Datum + template ::value, + bool IsScalar = std::is_base_of::value, + typename = enable_if_t> + Datum(T&& value) // NOLINT implicit conversion + : Datum(std::make_shared(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 00000000000..8fafcda3864 --- /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 00000000000..8412edd197d --- /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 + "$<$: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 00000000000..de996e4d264 --- /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 00000000000..90fba82a8e9 --- /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 00000000000..ddb4c120f2a --- /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 00000000000..ecffba3d109 --- /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 +#include +#include +#include + +#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 GetStorage(const Params&)> +class SimpleExtensionType : public ExtensionType { + public: + using ParamsType = Params; + + explicit SimpleExtensionType(std::shared_ptr storage_type, Params params = {}) + : ExtensionType(std::move(storage_type)), params_(std::move(params)) {} + + static std::shared_ptr Make(Params params) { + auto storage_type = GetStorage(params); + return std::make_shared(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(type); + if (ext_type.extension_name() != kExtensionName) return nullptr; + + return &::arrow::internal::checked_cast(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 + 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(other).params_; + return ExtensionEqualsImpl(params_, other_params).equal_; + } + + std::shared_ptr MakeArray(std::shared_ptr data) const override { + DCHECK_EQ(data->type->id(), Type::EXTENSION); + DCHECK_EQ(static_cast(*data->type).extension_name(), + kExtensionName); + return std::make_shared(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 + 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_; + std::vector members_; + }; + Result> Deserialize( + std::shared_ptr 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(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 + 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 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 00000000000..796f9ab5a72 --- /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 + +#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 FixedSizeBinaryScalarFromBytes( + const std::string& bytes) { + auto buf = Buffer::FromString(bytes); + auto type = fixed_size_binary(static_cast(buf->size())); + return std::make_shared(std::move(buf), std::move(type)); +} + +} // namespace + +Result 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 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( + 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 conditions, args; + std::vector 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 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 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(lit.i8())); + case substrait::Expression::Literal::kI16: + return Datum(static_cast(lit.i16())); + case substrait::Expression::Literal::kI32: + return Datum(static_cast(lit.i32())); + case substrait::Expression::Literal::kI64: + return Datum(static_cast(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(lit.timestamp()), TimeUnit::MICRO)); + + case substrait::Expression::Literal::kTimestampTz: + return Datum(TimestampScalar(static_cast(lit.timestamp_tz()), + TimeUnit::MICRO, TimestampTzTimezoneString())); + + case substrait::Expression::Literal::kDate: + return Datum(Date64Scalar(static_cast(lit.date()))); + case substrait::Expression::Literal::kTime: + return Datum(Time64Scalar(static_cast(lit.time()), TimeUnit::MICRO)); + + case substrait::Expression::Literal::kIntervalYearToMonth: + case substrait::Expression::Literal::kIntervalDayToSecond: { + Int32Builder builder; + std::shared_ptr 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(lit.fixed_char().size())))); + + case substrait::Expression::Literal::kVarChar: + return Datum( + ExtensionScalar(StringScalar(lit.var_char().value()), + varchar(static_cast(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 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 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 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 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{"key", "value"})); + return Datum(std::make_shared(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(keys->type(), values->type()); + ARROW_ASSIGN_OR_RAISE( + auto key_values, + StructArray::Make( + {std::move(keys), std::move(values)}, + checked_cast(*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 + Status Primitive(void (substrait::Expression::Literal::*set)(Arg), + const PrimitiveScalar& primitive_scalar) { + (lit_->*set)(static_cast(primitive_scalar.value)); + return Status::OK(); + } + + template + 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(*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(*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(); + + auto decimal_type = checked_cast(s.type.get()); + decimal->set_precision(decimal_type->precision()); + decimal->set_scale(decimal_type->scale()); + + decimal->set_value(reinterpret_cast(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(*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(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(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(*s.value); + + auto key_values = lit_->mutable_map()->mutable_key_values(); + key_values->Reserve(static_cast(kv_arr.length())); + + for (int64_t i = 0; i < s.value->length(); ++i) { + auto kv = internal::make_unique(); + + 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(*s.value)); + } + + if (UnwrapFixedChar(*s.type)) { + return FromBuffer(&Lit::set_fixed_char, + checked_cast(*s.value)); + } + + if (auto length = UnwrapVarChar(*s.type)) { + auto var_char = internal::make_unique(); + var_char->set_length(*length); + var_char->set_value(checked_cast(*s.value).value->ToString()); + + lit_->set_allocated_var_char(var_char.release()); + return Status::OK(); + } + + auto GetPairOfInts = [&] { + const auto& array = *checked_cast(*s.value).value; + auto ints = checked_cast(array).raw_values(); + return std::make_pair(ints[0], ints[1]); + }; + + if (UnwrapIntervalYear(*s.type)) { + auto interval_year = internal::make_unique(); + 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(); + 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> 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(); + + 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&& 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> MakeDirectReference( + std::unique_ptr&& expr, + std::unique_ptr&& 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(); + 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(); + 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> MakeStructFieldReference( + std::unique_ptr&& expr, int field) { + auto struct_field = + internal::make_unique(); + struct_field->set_field(field); + + auto ref_segment = internal::make_unique(); + 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> MakeListElementReference( + std::unique_ptr&& expr, int offset) { + auto list_element = + internal::make_unique(); + list_element->set_offset(offset); + + auto ref_segment = internal::make_unique(); + ref_segment->set_allocated_list_element(list_element.release()); + + return MakeDirectReference(std::move(expr), std::move(ref_segment)); +} + +Result> ToProto(const compute::Expression& expr, + ExtensionSet* ext_set) { + if (!expr.IsBound()) { + return Status::Invalid("ToProto requires a bound Expression"); + } + + auto out = internal::make_unique(); + + 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(); + + // don't try to convert argument 0 of the case_when; we have to convert the elements + // of make_struct individually + std::vector> 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(); + 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> 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(*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(); + if_clause->set_allocated_if_(arguments[0].release()); + if_clause->set_allocated_then(arguments[1].release()); + + auto if_then = internal::make_unique(); + 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(); + scalar_fn->set_function_reference(anchor); + scalar_fn->mutable_args()->Reserve(static_cast(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 00000000000..332b173b677 --- /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 + +#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 FromProto(const substrait::Expression&, const ExtensionSet&); + +ARROW_ENGINE_EXPORT +Result> ToProto(const compute::Expression&, + ExtensionSet*); + +ARROW_ENGINE_EXPORT +Result FromProto(const substrait::Expression::Literal&, const ExtensionSet&); + +ARROW_ENGINE_EXPORT +Result> 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 00000000000..084f8f3bb4f --- /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 +#include + +#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 + size_t operator()(const Ptr& type) const { + return type->Hash(); + } + + template + 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(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& 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(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(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 uris_; + std::unordered_map types_, functions_; +}; + +ExtensionSet::ExtensionSet(ExtensionIdRegistry* registry) + : registry_(registry), impl_(new Impl(), [](Impl* impl) { delete impl; }) {} + +Result ExtensionSet::Make(std::vector uris, + std::vector type_ids, + std::vector type_is_variation, + std::vector 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 + 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 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 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 +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 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 Uris() const override { + return {uris_.begin(), uris_.end()}; + } + + util::optional 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 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 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(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 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 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(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 uris_, names_, function_names_; + DataTypeVector types_; + std::vector type_is_variation_; + + // non-owning lookup helpers + std::vector type_ids_, function_ids_; + std::unordered_map id_to_index_, variation_id_to_index_; + std::unordered_map type_to_index_; + + std::vector function_name_ptrs_; + std::unordered_map function_id_to_index_; + std::unordered_map + 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 00000000000..e9ea80a0043 --- /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 + +#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 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& type; + bool is_variation; + }; + virtual util::optional GetType(const DataType&) const = 0; + virtual util::optional GetType(Id, bool is_variation) const = 0; + virtual Status RegisterType(Id, std::shared_ptr, 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 GetFunction(Id) const = 0; + virtual util::optional 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 Make( + std::vector uris, std::vector type_ids, + std::vector type_is_variation, std::vector 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& uris() const { return uris_; } + + const DataTypeVector& types() const { return types_; } + const std::vector& 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 EncodeType(const DataType& type); + + const std::vector& function_ids() const { return function_ids_; } + const std::vector& function_names() const { return function_names_; } + + Result EncodeFunction(util::string_view function_name); + + private: + ExtensionIdRegistry* registry_; + std::vector uris_; + DataTypeVector types_; + std::vector type_ids_; + std::vector type_is_variation_; + + std::vector function_ids_; + std::vector function_names_; + + // pimpl pattern to hide lookup details + struct Impl; + std::unique_ptr 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 00000000000..32de8980e3e --- /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 +#include + +#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 UuidGetStorage(const UuidExtensionParams&) { + return fixed_size_binary(16); +} +static auto kUuidExtensionParamsProperties = MakeProperties(); + +using UuidType = SimpleExtensionType; + +constexpr util::string_view kFixedCharExtensionName = "fixed_char"; +struct FixedCharExtensionParams { + int32_t length; +}; +std::shared_ptr FixedCharGetStorage(const FixedCharExtensionParams& params) { + return fixed_size_binary(params.length); +} +static auto kFixedCharExtensionParamsProperties = + MakeProperties(DataMember("length", &FixedCharExtensionParams::length)); + +using FixedCharType = + SimpleExtensionType; + +constexpr util::string_view kVarCharExtensionName = "varchar"; +struct VarCharExtensionParams { + int32_t length; +}; +std::shared_ptr VarCharGetStorage(const VarCharExtensionParams&) { + return utf8(); +} +static auto kVarCharExtensionParamsProperties = + MakeProperties(DataMember("length", &VarCharExtensionParams::length)); + +using VarCharType = + SimpleExtensionType; + +constexpr util::string_view kIntervalYearExtensionName = "interval_year"; +struct IntervalYearExtensionParams {}; +std::shared_ptr IntervalYearGetStorage(const IntervalYearExtensionParams&) { + return fixed_size_list(int32(), 2); +} +static auto kIntervalYearExtensionParamsProperties = MakeProperties(); + +using IntervalYearType = + SimpleExtensionType; + +constexpr util::string_view kIntervalDayExtensionName = "interval_day"; +struct IntervalDayExtensionParams {}; +std::shared_ptr IntervalDayGetStorage(const IntervalDayExtensionParams&) { + return fixed_size_list(int32(), 2); +} +static auto kIntervalDayExtensionParamsProperties = MakeProperties(); + +using IntervalDayType = + SimpleExtensionType; + +} // namespace + +std::shared_ptr uuid() { return UuidType::Make({}); } + +std::shared_ptr fixed_char(int32_t length) { + return FixedCharType::Make({length}); +} + +std::shared_ptr varchar(int32_t length) { return VarCharType::Make({length}); } + +std::shared_ptr interval_year() { return IntervalYearType::Make({}); } + +std::shared_ptr interval_day() { return IntervalDayType::Make({}); } + +bool UnwrapUuid(const DataType& t) { + if (UuidType::GetIf(t)) { + return true; + } + return false; +} + +util::optional UnwrapFixedChar(const DataType& t) { + if (auto params = FixedCharType::GetIf(t)) { + return params->length; + } + return util::nullopt; +} + +util::optional 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 00000000000..e689e94722e --- /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 + +#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 uuid(); + +/// fixed_size_binary(length) constrained to contain only valid UTF-8 +ARROW_ENGINE_EXPORT +std::shared_ptr fixed_char(int32_t length); + +/// utf8() constrained to be shorter than `length` +ARROW_ENGINE_EXPORT +std::shared_ptr varchar(int32_t length); + +/// fixed_size_list(int32(), 2) storing a number of [years, months] +ARROW_ENGINE_EXPORT +std::shared_ptr interval_year(); + +/// fixed_size_list(int32(), 2) storing a number of [days, seconds] +ARROW_ENGINE_EXPORT +std::shared_ptr 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 UnwrapFixedChar(const DataType&); + +/// Return Varchar (max) length if t is VarChar, otherwise nullopt +ARROW_ENGINE_EXPORT +util::optional 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 00000000000..90fda742713 --- /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 map; + + auto uris = plan->mutable_extension_uris(); + uris->Reserve(static_cast(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(); + 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(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(); + + if (ext_set.type_is_variation(anchor)) { + auto type_var = internal::make_unique(); + 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(); + 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(); + 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(); + ext_decl->set_allocated_extension_function(fn.release()); + extensions->AddAllocated(ext_decl.release()); + } + + return Status::OK(); +} + +namespace { +template +void SetElement(size_t i, const Element& element, std::vector* vector) { + DCHECK_LE(i, 1 << 20); + if (i >= vector->size()) { + vector->resize(i + 1); + } + (*vector)[i] = static_cast(element); +} +} // namespace + +Result GetExtensionSetFromPlan(const substrait::Plan& plan, + ExtensionIdRegistry* registry) { + std::vector 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 type_ids, function_ids; + std::vector 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 00000000000..5819ea209f2 --- /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 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 00000000000..75dc0ecff76 --- /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 +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 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(); + + 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 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(); + auto filesystem = std::make_shared(); + std::vector> 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 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 00000000000..b0e899a6af3 --- /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 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 00000000000..ea916d86757 --- /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 +#include +#include +#include +#include +#include + +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(buf.size())}; + + if (message->ParseFromZeroCopyStream(&buf_stream)) { + return Status::OK(); + } + return Status::IOError("ParseFromZeroCopyStream failed for ", full_name); +} + +template +Result ParseFromBuffer(const Buffer& buf) { + Message message; + ARROW_RETURN_NOT_OK( + ParseFromBufferImpl(buf, Message::descriptor()->full_name(), &message)); + return message; +} + +Result DeserializeRelation(const Buffer& buf, + const ExtensionSet& ext_set) { + ARROW_ASSIGN_OR_RAISE(auto rel, ParseFromBuffer(buf)); + return FromProto(rel, ext_set); +} + +Result> DeserializePlan( + const Buffer& buf, const ConsumerFactory& consumer_factory, + ExtensionSet* ext_set_out) { + ARROW_ASSIGN_OR_RAISE(auto plan, ParseFromBuffer(buf)); + + ARROW_ASSIGN_OR_RAISE(auto ext_set, GetExtensionSetFromPlan(plan)); + + std::vector 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> DeserializeSchema(const Buffer& buf, + const ExtensionSet& ext_set) { + ARROW_ASSIGN_OR_RAISE(auto named_struct, ParseFromBuffer(buf)); + return FromProto(named_struct, ext_set); +} + +Result> 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> DeserializeType(const Buffer& buf, + const ExtensionSet& ext_set) { + ARROW_ASSIGN_OR_RAISE(auto type, ParseFromBuffer(buf)); + ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(type, ext_set)); + return std::move(type_nullable.first); +} + +Result> 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 DeserializeExpression(const Buffer& buf, + const ExtensionSet& ext_set) { + ARROW_ASSIGN_OR_RAISE(auto expr, ParseFromBuffer(buf)); + return FromProto(expr, ext_set); +} + +Result> 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 +static Status CheckMessagesEquivalent(const Buffer& l_buf, const Buffer& r_buf) { + ARROW_ASSIGN_OR_RAISE(auto l, ParseFromBuffer(l_buf)); + ARROW_ASSIGN_OR_RAISE(auto r, ParseFromBuffer(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(l_buf, r_buf); + } + + if (message_name == "NamedStruct") { + return CheckMessagesEquivalent(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(l_buf, r_buf); + } + + if (message_name == "Rel") { + return CheckMessagesEquivalent(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 type_resolver; + if (!type_resolver) { + type_resolver.reset(google::protobuf::util::NewTypeResolverForDescriptorPool( + /*url_prefix=*/"", google::protobuf::DescriptorPool::generated_pool())); + } + return type_resolver.get(); +} + +Result> 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(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 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(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 00000000000..a9f0fcfca5a --- /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 +#include +#include + +#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()>; + +ARROW_ENGINE_EXPORT Result> DeserializePlan( + const Buffer&, const ConsumerFactory&, ExtensionSet* ext_set = NULLPTR); + +ARROW_ENGINE_EXPORT +Result> DeserializeType(const Buffer&, const ExtensionSet&); + +ARROW_ENGINE_EXPORT +Result> SerializeType(const DataType&, ExtensionSet*); + +ARROW_ENGINE_EXPORT +Result> DeserializeSchema(const Buffer&, const ExtensionSet&); + +ARROW_ENGINE_EXPORT +Result> SerializeSchema(const Schema&, ExtensionSet*); + +ARROW_ENGINE_EXPORT +Result DeserializeExpression(const Buffer&, const ExtensionSet&); + +ARROW_ENGINE_EXPORT +Result> SerializeExpression(const compute::Expression&, + ExtensionSet*); + +ARROW_ENGINE_EXPORT Result 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> SubstraitFromJSON(util::string_view type_name, + util::string_view json); + +ARROW_ENGINE_EXPORT +Result 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 00000000000..983ff6d5a3d --- /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 +#include +#include +#include + +#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 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 StripFieldNames(std::shared_ptr 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 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 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(*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(*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{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 00000000000..0b516436140 --- /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 +#include + +#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 +Status CheckVariation(const TypeMessage& type) { + if (type.type_variation_reference() == 0) return Status::OK(); + return Status::NotImplemented("Type variations for ", type.DebugString()); +} + +template +bool IsNullable(const TypeMessage& type) { + // FIXME what can we do with NULLABILITY_UNSPECIFIED + return type.nullability() != substrait::Type::NULLABILITY_REQUIRED; +} + +template +Result, bool>> FromProtoImpl(const TypeMessage& type, + A&&... args) { + RETURN_NOT_OK(CheckVariation(type)); + + return std::make_pair(std::static_pointer_cast( + std::make_shared(std::forward(args)...)), + IsNullable(type)); +} + +template +Result, bool>> FromProtoImpl( + const TypeMessage& type, std::shared_ptr type_factory(A...), A&&... args) { + RETURN_NOT_OK(CheckVariation(type)); + + return std::make_pair( + std::static_pointer_cast(type_factory(std::forward(args)...)), + IsNullable(type)); +} + +template +Result 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 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, bool>> FromProto( + const substrait::Type& type, const ExtensionSet& ext_set) { + switch (type.kind_case()) { + case substrait::Type::kBool: + return FromProtoImpl(type.bool_()); + + case substrait::Type::kI8: + return FromProtoImpl(type.i8()); + case substrait::Type::kI16: + return FromProtoImpl(type.i16()); + case substrait::Type::kI32: + return FromProtoImpl(type.i32()); + case substrait::Type::kI64: + return FromProtoImpl(type.i64()); + + case substrait::Type::kFp32: + return FromProtoImpl(type.fp32()); + case substrait::Type::kFp64: + return FromProtoImpl(type.fp64()); + + case substrait::Type::kString: + return FromProtoImpl(type.string()); + case substrait::Type::kBinary: + return FromProtoImpl(type.binary()); + + case substrait::Type::kTimestamp: + return FromProtoImpl(type.timestamp(), TimeUnit::MICRO); + case substrait::Type::kTimestampTz: + return FromProtoImpl(type.timestamp_tz(), TimeUnit::MICRO, + TimestampTzTimezoneString()); + case substrait::Type::kDate: + return FromProtoImpl(type.date()); + + case substrait::Type::kTime: + return FromProtoImpl(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(type.fixed_binary(), + type.fixed_binary().length()); + + case substrait::Type::kDecimal: { + const auto& decimal = type.decimal(); + return FromProtoImpl(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(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( + list, field("item", std::move(type_nullable.first), type_nullable.second)); + } + + case substrait::Type::kMap: { + const auto& map = type.map(); + + static const std::array 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( + 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 + Sub* SetWithThen(void (substrait::Type::*set_allocated_sub)(Sub*)) { + auto sub = internal::make_unique(); + 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 + Status SetWith(void (substrait::Type::*set_allocated_sub)(Sub*)) { + return SetWithThen(set_allocated_sub), Status::OK(); + } + + template + 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> ToProto(const DataType& type, bool nullable, + ExtensionSet* ext_set) { + auto out = internal::make_unique(); + RETURN_NOT_OK((DataTypeToProtoImpl{out.get(), nullable, ext_set})(type)); + return std::move(out); +} + +Result> 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* names) { + for (const auto& field : fields) { + *names->Add() = field->name(); + + if (field->type()->id() == Type::STRUCT) { + ToProtoGetDepthFirstNames(field->type()->fields(), names); + } + } +} +} // namespace + +Result> 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(); + + auto names = named_struct->mutable_names(); + names->Reserve(schema.num_fields()); + ToProtoGetDepthFirstNames(schema.fields(), names); + + auto struct_ = internal::make_unique(); + 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 00000000000..380c07024d0 --- /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 + +#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, bool>> FromProto(const substrait::Type&, + const ExtensionSet&); + +ARROW_ENGINE_EXPORT +Result> ToProto(const DataType&, bool nullable, + ExtensionSet*); + +ARROW_ENGINE_EXPORT +Result> FromProto(const substrait::NamedStruct&, + const ExtensionSet&); + +ARROW_ENGINE_EXPORT +Result> 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 00000000000..5b1651f78ab --- /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 2cf8c9913e5..bcebe3e73aa 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 9df3e3c74e3..e5a398b7014 100644 --- a/cpp/src/arrow/scalar.h +++ b/cpp/src/arrow/scalar.h @@ -345,8 +345,8 @@ struct ARROW_EXPORT TimestampScalar : public TemporalScalar { using TemporalScalar::TemporalScalar; TimestampScalar(typename TemporalScalar::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 @@ -533,6 +533,11 @@ struct ARROW_EXPORT ExtensionScalar : public Scalar { ExtensionScalar(std::shared_ptr storage, std::shared_ptr type) : Scalar(std::move(type), true), value(std::move(storage)) {} + template ::value>> + ExtensionScalar(Storage&& storage, std::shared_ptr type) + : ExtensionScalar(std::make_shared(std::move(storage)), std::move(type)) {} + std::shared_ptr value; }; diff --git a/cpp/src/arrow/status_test.cc b/cpp/src/arrow/status_test.cc index 10a79d9b990..a8e1d1ca9a8 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 ddfe60f1740..be88c3f93b4 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 @@ -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 DataEqMatcher DataEq(Data&& dat) { return DataEqMatcher(Datum(std::forward(dat))); } +/// Constructs an array with ArrayFromJSON against which arguments are matched +inline DataEqMatcher DataEqArray(const std::shared_ptr& type, + util::string_view json) { + return DataEq(ArrayFromJSON(type, json)); +} + +/// Constructs an array from a vector of optionals against which arguments are matched +template ::ArrayType, + typename BuilderType = typename TypeTraits::BuilderType, + typename ValueType = + typename ::arrow::stl::detail::DefaultValueAccessor::ValueType> +DataEqMatcher DataEqArray(T type, const std::vector>& values) { + // FIXME(bkietz) broken until DataType is move constructible + BuilderType builder(std::make_shared(std::move(type)), default_memory_pool()); + DCHECK_OK(builder.Reserve(static_cast(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& type, + util::string_view json) { + return DataEq(ScalarFromJSON(type, json)); +} + +/// Constructs a scalar against which arguments are matched +template ::ScalarType, + typename ValueType = typename ScalarType::ValueType> +DataEqMatcher DataEqScalar(T type, util::optional value) { + ScalarType expected(std::make_shared(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 2a382662497..5842d4bc92f 100644 --- a/cpp/src/arrow/type.cc +++ b/cpp/src/arrow/type.cc @@ -1544,7 +1544,7 @@ Result> Schema::AddField( Result> Schema::SetField( int i, const std::shared_ptr& 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( diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h index 4c439841ba2..7381d94b43e 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 fingerprint_; - mutable std::atomic metadata_fingerprint_; + mutable std::atomic fingerprint_{NULLPTR}; + mutable std::atomic 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 value_field() const { return children_[0]; } + const std::shared_ptr& value_field() const { return children_[0]; } std::shared_ptr value_type() const { return children_[0]->type(); } }; diff --git a/cpp/src/arrow/util/hashing.h b/cpp/src/arrow/util/hashing.h index 328d7e7ca21..d2c0178b008 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 against those) + hash_t operator()(const util::string_view& value) const { + return ComputeStringHash<0>(value.data(), static_cast(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 00000000000..a87949956df --- /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 + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +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(&::substrait::_Capabilities_SimpleExtension_default_instance_), + reinterpret_cast(&::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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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 diff --git a/cpp/src/generated/substrait/capabilities.pb.h b/cpp/src/generated/substrait/capabilities.pb.h new file mode 100644 index 00000000000..1ac303703ff --- /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 +#include + +#include +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +// @@protoc_insertion_point(includes) +#include +#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( + &_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(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& function_keys() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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& type_keys() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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& type_variation_keys() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 + 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 friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField function_keys_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField type_keys_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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( + &_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(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& substrait_versions() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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& advanced_extension_type_urls() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField substrait_versions_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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 +inline PROTOBUF_ALWAYS_INLINE +void Capabilities_SimpleExtension::set_uri(ArgT0&& arg0, ArgT... args) { + + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.SimpleExtension.function_keys) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Capabilities_SimpleExtension::function_keys() const { + // @@protoc_insertion_point(field_list:substrait.Capabilities.SimpleExtension.function_keys) + return function_keys_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.SimpleExtension.type_keys) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Capabilities_SimpleExtension::type_keys() const { + // @@protoc_insertion_point(field_list:substrait.Capabilities.SimpleExtension.type_keys) + return type_keys_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.SimpleExtension.type_variation_keys) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +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* +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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.substrait_versions) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Capabilities::substrait_versions() const { + // @@protoc_insertion_point(field_list:substrait.Capabilities.substrait_versions) + return substrait_versions_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.advanced_extension_type_urls) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +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* +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 +#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 00000000000..c58095ef801 --- /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 + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +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(&::substrait::_Expression_Enum_Empty_default_instance_), + reinterpret_cast(&::substrait::_Expression_Enum_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_VarChar_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_Decimal_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_Map_KeyValue_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_Map_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_Struct_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_List_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_default_instance_), + reinterpret_cast(&::substrait::_Expression_ScalarFunction_default_instance_), + reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_), + reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_Following_default_instance_), + reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_), + reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_), + reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_default_instance_), + reinterpret_cast(&::substrait::_Expression_WindowFunction_default_instance_), + reinterpret_cast(&::substrait::_Expression_IfThen_IfClause_default_instance_), + reinterpret_cast(&::substrait::_Expression_IfThen_default_instance_), + reinterpret_cast(&::substrait::_Expression_Cast_default_instance_), + reinterpret_cast(&::substrait::_Expression_SwitchExpression_IfValue_default_instance_), + reinterpret_cast(&::substrait::_Expression_SwitchExpression_default_instance_), + reinterpret_cast(&::substrait::_Expression_SingularOrList_default_instance_), + reinterpret_cast(&::substrait::_Expression_MultiOrList_Record_default_instance_), + reinterpret_cast(&::substrait::_Expression_MultiOrList_default_instance_), + reinterpret_cast(&::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_), + reinterpret_cast(&::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_), + reinterpret_cast(&::substrait::_Expression_EmbeddedFunction_default_instance_), + reinterpret_cast(&::substrait::_Expression_ReferenceSegment_MapKey_default_instance_), + reinterpret_cast(&::substrait::_Expression_ReferenceSegment_StructField_default_instance_), + reinterpret_cast(&::substrait::_Expression_ReferenceSegment_ListElement_default_instance_), + reinterpret_cast(&::substrait::_Expression_ReferenceSegment_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_Select_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_StructSelect_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_StructItem_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_ListSelect_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_MapSelect_MapKey_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_MapSelect_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_default_instance_), + reinterpret_cast(&::substrait::_Expression_FieldReference_RootReference_default_instance_), + reinterpret_cast(&::substrait::_Expression_FieldReference_default_instance_), + reinterpret_cast(&::substrait::_Expression_default_instance_), + reinterpret_cast(&::substrait::_SortField_default_instance_), + reinterpret_cast(&::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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(to)->MergeFrom( + static_cast(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(reinterpret_cast(&scale_) - + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&precision_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&scale_) - + reinterpret_cast(&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( + reinterpret_cast(&scale_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&precision_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&key_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&value_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&key_), + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(reinterpret_cast(&months_) - + reinterpret_cast(&years_)) + sizeof(months_)); + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.IntervalYearToMonth) +} + +inline void Expression_Literal_IntervalYearToMonth::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&years_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&months_) - + reinterpret_cast(&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( + reinterpret_cast(&months_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&years_), + reinterpret_cast(&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(reinterpret_cast(&seconds_) - + reinterpret_cast(&days_)) + sizeof(seconds_)); + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.IntervalDayToSecond) +} + +inline void Expression_Literal_IntervalDayToSecond::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&days_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&seconds_) - + reinterpret_cast(&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( + reinterpret_cast(&seconds_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&days_), + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(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(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(tag) == 85)) { + _internal_set_fp32(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // double fp64 = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 89)) { + _internal_set_fp64(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // string string = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(this) + static_cast( + reinterpret_cast(&output_type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&function_reference_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&output_type_), + reinterpret_cast(&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(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(to)->MergeFrom( + static_cast(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(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(to)->MergeFrom( + static_cast(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(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(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(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(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(to)->MergeFrom( + static_cast(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(reinterpret_cast(&phase_) - + reinterpret_cast(&function_reference_)) + sizeof(phase_)); + // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction) +} + +inline void Expression_WindowFunction::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&upper_bound_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&phase_) - + reinterpret_cast(&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( + reinterpret_cast(&phase_) - + reinterpret_cast(&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(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(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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&upper_bound_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&if__) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&then_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&if__), + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(this) + static_cast( + reinterpret_cast(&type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&input_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_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(&type_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&if__) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&then_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&if__), + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(this) + static_cast( + reinterpret_cast(&map_key_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&child_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&map_key_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&child_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&field_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&child_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&child_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&offset_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&child_), + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(to)->MergeFrom( + static_cast(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(this) + static_cast( + reinterpret_cast(&child_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&field_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&child_), + reinterpret_cast(&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(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(to)->MergeFrom( + static_cast(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(reinterpret_cast(&end_) - + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&start_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&end_) - + reinterpret_cast(&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( + reinterpret_cast(&end_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&start_), + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(to)->MergeFrom( + static_cast(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(to)->MergeFrom( + static_cast(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(this) + static_cast( + reinterpret_cast(&select_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&maintain_singular_struct_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&select_), + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(to)->MergeFrom( + static_cast(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(reinterpret_cast(&phase_) - + reinterpret_cast(&function_reference_)) + sizeof(phase_)); + // @@protoc_insertion_point(copy_constructor:substrait.AggregateFunction) +} + +inline void AggregateFunction::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&output_type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&phase_) - + reinterpret_cast(&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( + reinterpret_cast(&phase_) - + reinterpret_cast(&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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&output_type_), + reinterpret_cast(&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 diff --git a/cpp/src/generated/substrait/expression.pb.h b/cpp/src/generated/substrait/expression.pb.h new file mode 100644 index 00000000000..b7c2a920316 --- /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 +#include + +#include +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +#include "substrait/type.pb.h" +// @@protoc_insertion_point(includes) +#include +#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::min(), + SortField_SortDirection_SortField_SortDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::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 +inline const std::string& SortField_SortDirection_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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_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::min(), + AggregationPhase_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::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 +inline const std::string& AggregationPhase_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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_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( + &_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(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 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( + &_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(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 + 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 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( + &_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(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 + 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 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( + &_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(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 + 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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 + 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 + 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 + 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 + 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 + 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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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& prerequisite() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 + 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 friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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( + &_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(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& prerequisite() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 + 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 friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 + 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 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( + &_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(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 + 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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 + static inline const std::string& SortDirection_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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 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( + &_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(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 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 +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(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 +inline PROTOBUF_ALWAYS_INLINE +void Expression_Literal_VarChar::set_value(ArgT0&& arg0, ArgT... args) { + + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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 +inline PROTOBUF_ALWAYS_INLINE +void Expression_Literal_Decimal::set_value(ArgT0&& arg0, ArgT... args) { + + value_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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( + ::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( + ::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 +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(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 +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(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 +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(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 +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(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 +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(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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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 +inline PROTOBUF_ALWAYS_INLINE +void Expression_EmbeddedFunction_PythonPickleFunction::set_function(ArgT0&& arg0, ArgT... args) { + + function_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Expression_EmbeddedFunction_PythonPickleFunction::prerequisite() const { + // @@protoc_insertion_point(field_list:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + return prerequisite_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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 +inline PROTOBUF_ALWAYS_INLINE +void Expression_EmbeddedFunction_WebAssemblyFunction::set_script(ArgT0&& arg0, ArgT... args) { + + script_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite() const { + // @@protoc_insertion_point(field_list:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + return prerequisite_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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 +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(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 +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(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( + ::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( + ::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( + ::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( + ::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 +#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 00000000000..564fb8fb347 --- /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 + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +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(&::substrait::extensions::_SimpleExtensionURI_default_instance_), + reinterpret_cast(&::substrait::extensions::_SimpleExtensionDeclaration_ExtensionType_default_instance_), + reinterpret_cast(&::substrait::extensions::_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_), + reinterpret_cast(&::substrait::extensions::_SimpleExtensionDeclaration_ExtensionFunction_default_instance_), + reinterpret_cast(&::substrait::extensions::_SimpleExtensionDeclaration_default_instance_), + reinterpret_cast(&::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(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(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(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(to)->MergeFrom( + static_cast(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(reinterpret_cast(&type_anchor_) - + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&type_anchor_) - + reinterpret_cast(&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( + reinterpret_cast(&type_anchor_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&extension_uri_reference_), + reinterpret_cast(&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(reinterpret_cast(&type_variation_anchor_) - + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&type_variation_anchor_) - + reinterpret_cast(&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( + reinterpret_cast(&type_variation_anchor_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&extension_uri_reference_), + reinterpret_cast(&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(reinterpret_cast(&function_anchor_) - + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&function_anchor_) - + reinterpret_cast(&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( + reinterpret_cast(&function_anchor_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&extension_uri_reference_), + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(this) + static_cast( + reinterpret_cast(&optimization_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&enhancement_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&optimization_), + reinterpret_cast(&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 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 00000000000..ee6e5499e61 --- /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 +#include + +#include +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +// @@protoc_insertion_point(includes) +#include +#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( + &_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(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 + 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 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( + &_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(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 + 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 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( + &_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(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 + 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 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( + &_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(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 + 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 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( + &_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(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 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( + &_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(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 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 +inline PROTOBUF_ALWAYS_INLINE +void SimpleExtensionURI::set_uri(ArgT0&& arg0, ArgT... args) { + + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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 +inline PROTOBUF_ALWAYS_INLINE +void SimpleExtensionDeclaration_ExtensionType::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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 +inline PROTOBUF_ALWAYS_INLINE +void SimpleExtensionDeclaration_ExtensionTypeVariation::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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 +inline PROTOBUF_ALWAYS_INLINE +void SimpleExtensionDeclaration_ExtensionFunction::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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( + ::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( + ::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 +#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 00000000000..eb85050ab71 --- /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 + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +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(&::substrait::_FunctionSignature_FinalArgVariadic_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_FinalArgNormal_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Scalar_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Aggregate_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Window_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Description_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Implementation_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Argument_default_instance_), + reinterpret_cast(&::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(reinterpret_cast(&consistency_) - + reinterpret_cast(&min_args_)) + sizeof(consistency_)); + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.FinalArgVariadic) +} + +inline void FunctionSignature_FinalArgVariadic::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&min_args_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&consistency_) - + reinterpret_cast(&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( + reinterpret_cast(&consistency_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&min_args_), + reinterpret_cast(&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(reinterpret_cast(&session_dependent_) - + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&description_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&session_dependent_) - + reinterpret_cast(&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( + reinterpret_cast(&session_dependent_) - + reinterpret_cast(&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(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(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(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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&description_), + reinterpret_cast(&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(reinterpret_cast(&max_set_) - + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&description_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&max_set_) - + reinterpret_cast(&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( + reinterpret_cast(&max_set_) - + reinterpret_cast(&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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&description_), + reinterpret_cast(&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(reinterpret_cast(&max_set_) - + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&description_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&max_set_) - + reinterpret_cast(&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( + reinterpret_cast(&max_set_) - + reinterpret_cast(&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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&description_), + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(to)->MergeFrom( + static_cast(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(this) + static_cast( + reinterpret_cast(&type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&constant_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_), + reinterpret_cast(&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(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(to)->MergeFrom( + static_cast(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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 diff --git a/cpp/src/generated/substrait/function.pb.h b/cpp/src/generated/substrait/function.pb.h new file mode 100644 index 00000000000..e566263d2f6 --- /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 +#include + +#include +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +#include "substrait/type.pb.h" +#include "substrait/parameterized_types.pb.h" +#include "substrait/type_expressions.pb.h" +// @@protoc_insertion_point(includes) +#include +#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::min(), + FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::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 +inline const std::string& FunctionSignature_FinalArgVariadic_ParameterConsistency_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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_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::min(), + FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::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 +inline const std::string& FunctionSignature_Window_WindowType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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_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::min(), + FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::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 +inline const std::string& FunctionSignature_Implementation_Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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_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( + &_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(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 + static inline const std::string& ParameterConsistency_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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 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( + &_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(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 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( + &_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(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& name() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 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 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( + &_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(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 + 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 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( + &_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(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 + static inline const std::string& WindowType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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& name() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 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 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( + &_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(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 + 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 + 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 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( + &_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(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 + static inline const std::string& Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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 + 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 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( + &_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(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 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( + &_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(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 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( + &_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(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& options() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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( + &_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(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 + 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 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( + &_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(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 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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Scalar.name) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +FunctionSignature_Scalar::name() const { + // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.name) + return name_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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( + ::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( + ::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 +inline PROTOBUF_ALWAYS_INLINE +void FunctionSignature_Aggregate::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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( + ::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( + ::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( + ::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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Window.name) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +FunctionSignature_Window::name() const { + // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.name) + return name_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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( + ::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( + ::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( + ::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 +inline PROTOBUF_ALWAYS_INLINE +void FunctionSignature_Description::set_language(ArgT0&& arg0, ArgT... args) { + + language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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 +inline PROTOBUF_ALWAYS_INLINE +void FunctionSignature_Description::set_body(ArgT0&& arg0, ArgT... args) { + + body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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 +inline PROTOBUF_ALWAYS_INLINE +void FunctionSignature_Implementation::set_uri(ArgT0&& arg0, ArgT... args) { + + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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( + ::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( + ::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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Argument.EnumArgument.options) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +FunctionSignature_Argument_EnumArgument::options() const { + // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Argument.EnumArgument.options) + return options_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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 +inline PROTOBUF_ALWAYS_INLINE +void FunctionSignature_Argument::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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 +#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 00000000000..a37885aca41 --- /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 + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +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(&::substrait::_ParameterizedType_TypeParameter_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_IntegerParameter_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_NullableInteger_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedFixedChar_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedVarChar_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedFixedBinary_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedDecimal_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedStruct_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedNamedStruct_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedList_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedMap_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_IntegerOption_default_instance_), + reinterpret_cast(&::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(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(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(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(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(to)->MergeFrom( + static_cast(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(this) + static_cast( + reinterpret_cast(&range_start_inclusive_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&range_end_exclusive_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&range_start_inclusive_), + reinterpret_cast(&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(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(to)->MergeFrom( + static_cast(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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedFixedChar) +} + +inline void ParameterizedType_ParameterizedFixedChar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&length_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedVarChar) +} + +inline void ParameterizedType_ParameterizedVarChar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&length_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedFixedBinary) +} + +inline void ParameterizedType_ParameterizedFixedBinary::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&length_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedDecimal) +} + +inline void ParameterizedType_ParameterizedDecimal::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&scale_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&scale_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedStruct) +} + +inline void ParameterizedType_ParameterizedStruct::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_pointer_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&variation_pointer_), + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedList) +} + +inline void ParameterizedType_ParameterizedList::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&type_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedMap) +} + +inline void ParameterizedType_ParameterizedMap::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&key_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&key_), + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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 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 00000000000..ae85f689870 --- /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 +#include + +#include +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include "substrait/type.pb.h" +// @@protoc_insertion_point(includes) +#include +#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( + &_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(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 + 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 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( + &_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(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 + 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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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& names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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 +inline PROTOBUF_ALWAYS_INLINE +void ParameterizedType_TypeParameter::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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 +inline PROTOBUF_ALWAYS_INLINE +void ParameterizedType_IntegerParameter::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.ParameterizedType.ParameterizedNamedStruct.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +ParameterizedType_ParameterizedNamedStruct::names() const { + // @@protoc_insertion_point(field_list:substrait.ParameterizedType.ParameterizedNamedStruct.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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( + ::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( + ::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( + ::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( + ::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 +#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 00000000000..4b77e56bfbd --- /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 + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +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(&::substrait::_PlanRel_default_instance_), + reinterpret_cast(&::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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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 diff --git a/cpp/src/generated/substrait/plan.pb.h b/cpp/src/generated/substrait/plan.pb.h new file mode 100644 index 00000000000..b31f812c569 --- /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 +#include + +#include +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include "substrait/relations.pb.h" +#include "substrait/extensions/extensions.pb.h" +// @@protoc_insertion_point(includes) +#include +#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( + &_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(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 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( + &_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(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& expected_type_urls() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 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 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( + ::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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.Plan.expected_type_urls) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Plan::expected_type_urls() const { + // @@protoc_insertion_point(field_list:substrait.Plan.expected_type_urls) + return expected_type_urls_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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 +#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 00000000000..f4d4e904448 --- /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 + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +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(&::substrait::_RelCommon_Direct_default_instance_), + reinterpret_cast(&::substrait::_RelCommon_Emit_default_instance_), + reinterpret_cast(&::substrait::_RelCommon_Hint_Stats_default_instance_), + reinterpret_cast(&::substrait::_RelCommon_Hint_RuntimeConstraint_default_instance_), + reinterpret_cast(&::substrait::_RelCommon_Hint_default_instance_), + reinterpret_cast(&::substrait::_RelCommon_default_instance_), + reinterpret_cast(&::substrait::_ReadRel_NamedTable_default_instance_), + reinterpret_cast(&::substrait::_ReadRel_VirtualTable_default_instance_), + reinterpret_cast(&::substrait::_ReadRel_ExtensionTable_default_instance_), + reinterpret_cast(&::substrait::_ReadRel_LocalFiles_FileOrFiles_default_instance_), + reinterpret_cast(&::substrait::_ReadRel_LocalFiles_default_instance_), + reinterpret_cast(&::substrait::_ReadRel_default_instance_), + reinterpret_cast(&::substrait::_ProjectRel_default_instance_), + reinterpret_cast(&::substrait::_JoinRel_default_instance_), + reinterpret_cast(&::substrait::_FetchRel_default_instance_), + reinterpret_cast(&::substrait::_AggregateRel_Grouping_default_instance_), + reinterpret_cast(&::substrait::_AggregateRel_Measure_default_instance_), + reinterpret_cast(&::substrait::_AggregateRel_default_instance_), + reinterpret_cast(&::substrait::_SortRel_default_instance_), + reinterpret_cast(&::substrait::_FilterRel_default_instance_), + reinterpret_cast(&::substrait::_SetRel_default_instance_), + reinterpret_cast(&::substrait::_ExtensionSingleRel_default_instance_), + reinterpret_cast(&::substrait::_ExtensionLeafRel_default_instance_), + reinterpret_cast(&::substrait::_ExtensionMultiRel_default_instance_), + reinterpret_cast(&::substrait::_RelRoot_default_instance_), + reinterpret_cast(&::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(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_output_mapping(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(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(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(to)->MergeFrom( + static_cast(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(reinterpret_cast(&record_size_) - + reinterpret_cast(&row_count_)) + sizeof(record_size_)); + // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint.Stats) +} + +inline void RelCommon_Hint_Stats::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&advanced_extension_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&record_size_) - + reinterpret_cast(&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( + reinterpret_cast(&record_size_) - + reinterpret_cast(&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(tag) == 9)) { + row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // double record_size = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { + record_size_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(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(to)->MergeFrom( + static_cast(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(&advanced_extension_), + reinterpret_cast(&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(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(to)->MergeFrom( + static_cast(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(this) + static_cast( + reinterpret_cast(&stats_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&stats_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&hint_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&hint_), + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(to)->MergeFrom( + static_cast(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(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(to)->MergeFrom( + static_cast(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(reinterpret_cast(&length_) - + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&format_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&length_) - + reinterpret_cast(&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( + reinterpret_cast(&length_) - + reinterpret_cast(&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(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(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(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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&format_), + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&common_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&common_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&common_), + reinterpret_cast(&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(reinterpret_cast(&count_) - + reinterpret_cast(&offset_)) + sizeof(count_)); + // @@protoc_insertion_point(copy_constructor:substrait.FetchRel) +} + +inline void FetchRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&count_) - + reinterpret_cast(&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( + reinterpret_cast(&count_) - + reinterpret_cast(&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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&common_), + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(this) + static_cast( + reinterpret_cast(&measure_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&filter_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&measure_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&common_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&common_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&common_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&op_) - + reinterpret_cast(&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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(&common_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&detail_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&common_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&detail_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&common_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&detail_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&common_), + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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 diff --git a/cpp/src/generated/substrait/relations.pb.h b/cpp/src/generated/substrait/relations.pb.h new file mode 100644 index 00000000000..11f499cb1ab --- /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 +#include + +#include +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +#include "substrait/type.pb.h" +#include "substrait/expression.pb.h" +#include "substrait/extensions/extensions.pb.h" +#include +// @@protoc_insertion_point(includes) +#include +#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::min(), + ReadRel_LocalFiles_FileOrFiles_FileFormat_ReadRel_LocalFiles_FileOrFiles_FileFormat_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::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 +inline const std::string& ReadRel_LocalFiles_FileOrFiles_FileFormat_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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_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::min(), + JoinRel_JoinType_JoinRel_JoinType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::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 +inline const std::string& JoinRel_JoinType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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_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::min(), + SetRel_SetOp_SetRel_SetOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::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 +inline const std::string& SetRel_SetOp_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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_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( + &_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(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 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( + &_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(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 friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > output_mapping_; + mutable std::atomic _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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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& names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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( + &_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(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 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( + &_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(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 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( + &_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(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 + static inline const std::string& FileFormat_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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 + 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 + 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 + 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 + 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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 + static inline const std::string& JoinType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 + static inline const std::string& SetOp_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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& names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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( + &_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(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 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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.ReadRel.NamedTable.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +ReadRel_NamedTable::names() const { + // @@protoc_insertion_point(field_list:substrait.ReadRel.NamedTable.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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( + ::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( + ::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 +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(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 +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(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 +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(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 +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(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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.RelRoot.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +RelRoot::names() const { + // @@protoc_insertion_point(field_list:substrait.RelRoot.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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 +#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 00000000000..5bb5b015941 --- /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 + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +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(&::substrait::_Type_Boolean_default_instance_), + reinterpret_cast(&::substrait::_Type_I8_default_instance_), + reinterpret_cast(&::substrait::_Type_I16_default_instance_), + reinterpret_cast(&::substrait::_Type_I32_default_instance_), + reinterpret_cast(&::substrait::_Type_I64_default_instance_), + reinterpret_cast(&::substrait::_Type_FP32_default_instance_), + reinterpret_cast(&::substrait::_Type_FP64_default_instance_), + reinterpret_cast(&::substrait::_Type_String_default_instance_), + reinterpret_cast(&::substrait::_Type_Binary_default_instance_), + reinterpret_cast(&::substrait::_Type_Timestamp_default_instance_), + reinterpret_cast(&::substrait::_Type_Date_default_instance_), + reinterpret_cast(&::substrait::_Type_Time_default_instance_), + reinterpret_cast(&::substrait::_Type_TimestampTZ_default_instance_), + reinterpret_cast(&::substrait::_Type_IntervalYear_default_instance_), + reinterpret_cast(&::substrait::_Type_IntervalDay_default_instance_), + reinterpret_cast(&::substrait::_Type_UUID_default_instance_), + reinterpret_cast(&::substrait::_Type_FixedChar_default_instance_), + reinterpret_cast(&::substrait::_Type_VarChar_default_instance_), + reinterpret_cast(&::substrait::_Type_FixedBinary_default_instance_), + reinterpret_cast(&::substrait::_Type_Decimal_default_instance_), + reinterpret_cast(&::substrait::_Type_Struct_default_instance_), + reinterpret_cast(&::substrait::_Type_List_default_instance_), + reinterpret_cast(&::substrait::_Type_Map_default_instance_), + reinterpret_cast(&::substrait::_Type_default_instance_), + reinterpret_cast(&::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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.Boolean) +} + +inline void Type_Boolean::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.I8) +} + +inline void Type_I8::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.I16) +} + +inline void Type_I16::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.I32) +} + +inline void Type_I32::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.I64) +} + +inline void Type_I64::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.FP32) +} + +inline void Type_FP32::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.FP64) +} + +inline void Type_FP64::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.String) +} + +inline void Type_String::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.Binary) +} + +inline void Type_Binary::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.Timestamp) +} + +inline void Type_Timestamp::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.Date) +} + +inline void Type_Date::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.Time) +} + +inline void Type_Time::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.TimestampTZ) +} + +inline void Type_TimestampTZ::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.IntervalYear) +} + +inline void Type_IntervalYear::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.IntervalDay) +} + +inline void Type_IntervalDay::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.UUID) +} + +inline void Type_UUID::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.FixedChar) +} + +inline void Type_FixedChar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&length_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.VarChar) +} + +inline void Type_VarChar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&length_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.FixedBinary) +} + +inline void Type_FixedBinary::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&length_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&scale_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.Decimal) +} + +inline void Type_Decimal::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&scale_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&scale_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.Struct) +} + +inline void Type_Struct::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&type_variation_reference_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.List) +} + +inline void Type_List::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&type_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.Type.Map) +} + +inline void Type_Map::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&key_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&key_), + reinterpret_cast(&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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(to)->MergeFrom( + static_cast(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 diff --git a/cpp/src/generated/substrait/type.pb.h b/cpp/src/generated/substrait/type.pb.h new file mode 100644 index 00000000000..b528e2f1b56 --- /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 +#include + +#include +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +// @@protoc_insertion_point(includes) +#include +#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::min(), + Type_Nullability_Type_Nullability_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::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 +inline const std::string& Type_Nullability_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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_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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 + static inline const std::string& Nullability_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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 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( + &_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(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& names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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( + ::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( + ::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( + ::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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.NamedStruct.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +NamedStruct::names() const { + // @@protoc_insertion_point(field_list:substrait.NamedStruct.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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( + ::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 +#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 00000000000..1179ab8e3ad --- /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 + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +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(&::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionVarChar_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionDecimal_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionStruct_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionNamedStruct_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionList_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionMap_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_IfElse_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_UnaryOp_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_BinaryOp_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ReturnProgram_Assignment_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ReturnProgram_default_instance_), + reinterpret_cast(&::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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionFixedChar) +} + +inline void DerivationExpression_ExpressionFixedChar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&length_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionVarChar) +} + +inline void DerivationExpression_ExpressionVarChar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&length_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionFixedBinary) +} + +inline void DerivationExpression_ExpressionFixedBinary::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&length_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionDecimal) +} + +inline void DerivationExpression_ExpressionDecimal::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&scale_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&scale_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionStruct) +} + +inline void DerivationExpression_ExpressionStruct::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_pointer_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&variation_pointer_), + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionList) +} + +inline void DerivationExpression_ExpressionList::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&type_), + reinterpret_cast(&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(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionMap) +} + +inline void DerivationExpression_ExpressionMap::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&key_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&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( + reinterpret_cast(&nullability_) - + reinterpret_cast(&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(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(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(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(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(to)->MergeFrom( + static_cast(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(&key_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&if_condition_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&else_return_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&if_condition_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&arg_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&op_type_) - + reinterpret_cast(&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(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(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(to)->MergeFrom( + static_cast(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(&arg_), + reinterpret_cast(&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(this) + static_cast( + reinterpret_cast(&arg1_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&op_type_) - + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(&arg1_), + reinterpret_cast(&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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(to)->MergeFrom( + static_cast(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(to)->MergeFrom( + static_cast(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 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 00000000000..0548e41e676 --- /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 +#include + +#include +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +#include "substrait/type.pb.h" +// @@protoc_insertion_point(includes) +#include +#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::min(), + DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::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 +inline const std::string& DerivationExpression_UnaryOp_UnaryOpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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_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::min(), + DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::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 +inline const std::string& DerivationExpression_BinaryOp_BinaryOpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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_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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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& names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* 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 friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField 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( + &_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(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 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( + &_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(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 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( + &_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(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 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( + &_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(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 + static inline const std::string& UnaryOpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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 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( + &_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(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 + static inline const std::string& BinaryOpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::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 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( + &_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(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 + 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 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( + &_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(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 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( + &_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(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 + 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 + 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 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( + ::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( + ::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( + ::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( + ::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( + ::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(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(value), size); + // @@protoc_insertion_point(field_add_pointer:substrait.DerivationExpression.ExpressionNamedStruct.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +DerivationExpression_ExpressionNamedStruct::names() const { + // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ExpressionNamedStruct.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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( + ::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 +inline PROTOBUF_ALWAYS_INLINE +void DerivationExpression_ReturnProgram_Assignment::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(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( + ::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( + ::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 +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(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 +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(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 +#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 d8eeb7bab0e..dbe0b5c4bda 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 cf25ba871b5..4ece6ec829b 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 6229e0aec39..671b11cd362 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 00000000000..8909ae7372d --- /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 +# - interval +# - interval +# - 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