Merge 19788e571e into 44b4bd38b9

Enable cluster table functions for DataLake Storages

.gitmodules

@@ -351,6 +351,9 @@
 [submodule "contrib/idna"]
 	path = contrib/idna
 	url = https://github.com/ada-url/idna.git
+[submodule "contrib/google-cloud-cpp"]
+	path = contrib/google-cloud-cpp
+	url = https://github.com/ClickHouse/google-cloud-cpp.git
 [submodule "contrib/rust_vendor"]
 	path = contrib/rust_vendor
 	url = https://github.com/ClickHouse/rust_vendor.git

ci/jobs/scripts/check_style/aspell-ignore/en/aspell-dict.txt

@@ -1211,6 +1211,7 @@ arrayReverse
 arrayReverseFill
 arrayReverseSort
 arrayReverseSplit
+arrayRocAUC
 arrayRotateLeft
 arrayRotateRight
 arrayShiftLeft

contrib/CMakeLists.txt

@@ -219,6 +219,8 @@ add_contrib (prometheus-protobufs-cmake prometheus-protobufs prometheus-protobuf
 
 add_contrib (numactl-cmake numactl)
 
+add_contrib (google-cloud-cpp-cmake google-cloud-cpp) # requires grpc, protobuf, absl
+
 add_contrib (jwt-cpp-cmake jwt-cpp)
 
 # Put all targets defined here and in subdirectories under "contrib/<immediate-subdir>" folders in GUI-based IDEs.

contrib/google-cloud-cpp

@@ -0,0 +1 @@
+Subproject commit 83f30caadb8613fb5c408d8c2fd545291596b53f

contrib/google-cloud-cpp-cmake/CMakeLists.txt

@@ -0,0 +1,105 @@
+set(ENABLE_GOOGLE_CLOUD_CPP_DEFAULT OFF)
+
+if(ENABLE_LIBRARIES AND CLICKHOUSE_CLOUD AND OS_LINUX)
+    set(ENABLE_GOOGLE_CLOUD_CPP_DEFAULT ON)
+endif()
+
+option(ENABLE_GOOGLE_CLOUD_CPP "Enable Google Cloud Cpp" ${ENABLE_GOOGLE_CLOUD_CPP_DEFAULT})
+
+if(NOT ENABLE_GOOGLE_CLOUD_CPP)
+    message(STATUS "Not using Google Cloud Cpp")
+    return()
+endif()
+
+if(NOT ENABLE_GRPC)
+    message (${RECONFIGURE_MESSAGE_LEVEL} "Can't use Google Cloud Cpp without gRPC")
+endif()
+if (NOT ENABLE_PROTOBUF)
+    message( ${RECONFIGURE_MESSAGE_LEVEL} "Can't use Google Cloud Cpp without protobuf")
+endif()
+
+# Gather sources and options.
+set(GOOGLE_CLOUD_CPP_SOURCES)
+set(GOOGLE_CLOUD_CPP_PUBLIC_INCLUDES)
+set(GOOGLE_CLOUD_CPP_PRIVATE_INCLUDES)
+set(GOOGLE_CLOUD_CPP_PRIVATE_LIBS)
+
+# Directories.
+SET(GOOGLE_CLOUD_CPP_DIR "${ClickHouse_SOURCE_DIR}/contrib/google-cloud-cpp" )
+list(APPEND GOOGLE_CLOUD_CPP_PRIVATE_INCLUDES "${GOOGLE_CLOUD_CPP_DIR}")
+
+# Set the PROJECT_SOURCE_DIR so that all Google Cloud cmake files work
+set(PROJECT_SOURCE_DIR_BAK ${PROJECT_SOURCE_DIR})
+set(PROJECT_SOURCE_DIR ${GOOGLE_CLOUD_CPP_DIR})
+
+list(APPEND CMAKE_MODULE_PATH "${GOOGLE_CLOUD_CPP_DIR}/cmake")
+
+# Building this target results in all protobufs being compiled.
+add_custom_target(google-cloud-cpp-protos)
+
+include("GoogleCloudCppLibrary")
+
+# Set some variables required for googleapis CMakeLists.txt to work.
+set(GOOGLE_CLOUD_CPP_ENABLE_GRPC ON)
+set(PROJECT_VERSION "1")
+set(PROJECT_VERSION_MAJOR "1")
+set(PROTO_INCLUDE_DIR "${ClickHouse_SOURCE_DIR}/contrib/google-protobuf/src")
+set(GOOGLE_CLOUD_CPP_GRPC_PLUGIN_EXECUTABLE $<TARGET_FILE:grpc_cpp_plugin>)
+
+include(GoogleApis.cmake)
+
+add_library(gRPC::grpc++ ALIAS _ch_contrib_grpc)
+add_library(gRPC::grpc ALIAS _ch_contrib_grpc)
+
+# google-cloud-cpp-kms.
+google_cloud_cpp_add_library_protos(kms)
+
+include(google_cloud_cpp_common.cmake)
+include(google_cloud_cpp_grpc_utils.cmake)
+
+SET(GOOGLE_CLOUD_CPP_KMS_DIR "${GOOGLE_CLOUD_CPP_DIR}/google/cloud/kms")
+
+file(GLOB GOOGLE_CLOUD_CPP_KMS_SRC
+    "${GOOGLE_CLOUD_CPP_KMS_DIR}/v1/*.cc"
+    "${GOOGLE_CLOUD_CPP_KMS_DIR}/v1/internal/*.cc"
+    "${GOOGLE_CLOUD_CPP_KMS_DIR}/inventory/v1/*.cc"
+)
+
+list(APPEND GOOGLE_CLOUD_CPP_SOURCES ${GOOGLE_CLOUD_CPP_KMS_SRC})
+list(APPEND GOOGLE_CLOUD_CPP_PUBLIC_INCLUDES "${GOOGLE_CLOUD_CPP_DIR}" "${CMAKE_CURRENT_BINARY_DIR}")
+
+set(GRPC_INCLUDE_DIR "${ClickHouse_SOURCE_DIR}/contrib/grpc")
+list(APPEND GOOGLE_CLOUD_CPP_PUBLIC_INCLUDES "${GRPC_INCLUDE_DIR}/include" "${GRPC_INCLUDE_DIR}/spm-cpp-include")
+
+# Restore the PROJECT_SOURCE_DIR.
+set(PROJECT_SOURCE_DIR ${PROJECT_SOURCE_DIR_BAK})
+
+# Link against external libraries.
+list(APPEND GOOGLE_CLOUD_CPP_PRIVATE_LIBS
+    google_cloud_cpp_common
+    google_cloud_cpp_grpc_utils
+    google_cloud_cpp_kms_protos
+    google_cloud_cpp_cloud_location_locations_protos
+    google_cloud_cpp_iam_v1_iam_policy_protos
+    gRPC::grpc++
+    absl::optional
+)
+
+list(APPEND GOOGLE_CLOUD_CPP_PUBLIC_LIBS
+    absl::optional
+    gRPC::grpc++
+)
+
+# Add library.
+add_library(_gcloud ${GOOGLE_CLOUD_CPP_SOURCES})
+
+target_include_directories(_gcloud SYSTEM PUBLIC ${GOOGLE_CLOUD_CPP_PUBLIC_INCLUDES})
+target_include_directories(_gcloud SYSTEM PRIVATE ${GOOGLE_CLOUD_CPP_PRIVATE_INCLUDES})
+target_link_libraries(_gcloud PRIVATE ${GOOGLE_CLOUD_CPP_PRIVATE_LIBS})
+
+# The library is large - avoid bloat.
+if (OMIT_HEAVY_DEBUG_SYMBOLS)
+    target_compile_options(_gcloud PRIVATE -g0)
+endif()
+
+add_library(ch_contrib::google_cloud_cpp ALIAS _gcloud)

contrib/google-cloud-cpp-cmake/GoogleApis.cmake

@@ -0,0 +1,469 @@
+# ~~~
+# Copyright 2020 Google LLC
+#
+# Licensed 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
+#
+#     https://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.
+# ~~~
+
+# File copied from google-cloud-cpp/external/googleapis/CMakeLists.txt with minor modifications.
+
+if (NOT GOOGLE_CLOUD_CPP_ENABLE_GRPC)
+    return()
+endif ()
+
+include(GoogleapisConfig)
+
+set(GOOGLE_CLOUD_CPP_GOOGLEAPIS_URL
+    "https://github.com/googleapis/googleapis/archive/${_GOOGLE_CLOUD_CPP_GOOGLEAPIS_COMMIT_SHA}.tar.gz"
+    "https://storage.googleapis.com/cloud-cpp-community-archive/github.com/googleapis/googleapis/archive/${_GOOGLE_CLOUD_CPP_GOOGLEAPIS_COMMIT_SHA}.tar.gz"
+)
+set(GOOGLE_CLOUD_CPP_GOOGLEAPIS_URL_HASH
+    "${_GOOGLE_CLOUD_CPP_GOOGLEAPIS_SHA256}")
+if (GOOGLE_CLOUD_CPP_OVERRIDE_GOOGLEAPIS_URL)
+    set(GOOGLE_CLOUD_CPP_GOOGLEAPIS_URL
+        ${GOOGLE_CLOUD_CPP_OVERRIDE_GOOGLEAPIS_URL})
+endif ()
+if (GOOGLE_CLOUD_CPP_OVERRIDE_GOOGLEAPIS_URL_HASH)
+    set(GOOGLE_CLOUD_CPP_GOOGLEAPIS_URL_HASH
+        "${GOOGLE_CLOUD_CPP_OVERRIDE_GOOGLEAPIS_URL_HASH}")
+endif ()
+
+set(EXTERNAL_GOOGLEAPIS_PROTO_FILES
+    # cmake-format: sort
+    "google/api/annotations.proto"
+    "google/api/auth.proto"
+    "google/api/backend.proto"
+    "google/api/billing.proto"
+    "google/api/client.proto"
+    "google/api/config_change.proto"
+    "google/api/consumer.proto"
+    "google/api/context.proto"
+    "google/api/control.proto"
+    "google/api/distribution.proto"
+    "google/api/documentation.proto"
+    "google/api/endpoint.proto"
+    "google/api/error_reason.proto"
+    "google/api/field_behavior.proto"
+    "google/api/field_info.proto"
+    "google/api/http.proto"
+    "google/api/httpbody.proto"
+    "google/api/label.proto"
+    "google/api/launch_stage.proto"
+    "google/api/log.proto"
+    "google/api/logging.proto"
+    "google/api/metric.proto"
+    "google/api/monitored_resource.proto"
+    "google/api/monitoring.proto"
+    "google/api/policy.proto"
+    "google/api/quota.proto"
+    "google/api/resource.proto"
+    "google/api/routing.proto"
+    "google/api/service.proto"
+    "google/api/source_info.proto"
+    "google/api/system_parameter.proto"
+    "google/api/usage.proto"
+    "google/api/visibility.proto"
+    "google/cloud/extended_operations.proto"
+    "google/cloud/location/locations.proto"
+    # orgpolicy/v**1** is used *indirectly* by google/cloud/asset, therefore it
+    # does not appear in protolists/asset.list. In addition, it is not compiled
+    # by any other library. So, added manually.
+    "google/cloud/orgpolicy/v1/orgpolicy.proto"
+    # Some gRPC based authentication is implemented by the IAM Credentials
+    # service.
+    "google/iam/credentials/v1/common.proto"
+    "google/iam/credentials/v1/iamcredentials.proto"
+    # We expose google::iam::v1::Policy in our google::cloud::IAMUpdater
+    "google/iam/v1/iam_policy.proto"
+    "google/iam/v1/options.proto"
+    "google/iam/v1/policy.proto"
+    "google/longrunning/operations.proto"
+    "google/rpc/code.proto"
+    "google/rpc/context/attribute_context.proto"
+    "google/rpc/error_details.proto"
+    "google/rpc/status.proto"
+    "google/type/calendar_period.proto"
+    "google/type/color.proto"
+    "google/type/date.proto"
+    "google/type/datetime.proto"
+    "google/type/dayofweek.proto"
+    "google/type/decimal.proto"
+    "google/type/expr.proto"
+    "google/type/fraction.proto"
+    "google/type/interval.proto"
+    "google/type/latlng.proto"
+    "google/type/localized_text.proto"
+    "google/type/money.proto"
+    "google/type/month.proto"
+    "google/type/phone_number.proto"
+    "google/type/postal_address.proto"
+    "google/type/quaternion.proto"
+    "google/type/timeofday.proto")
+
+include(GoogleCloudCppCommonOptions)
+
+# Set EXTERNAL_GOOGLEAPIS_SOURCE in the parent directory, as it is used by all
+# the generated libraries.  The Conan packages (https://conan.io), will need to
+# patch this value.  Setting the value in a single place makes such patching
+# easier.
+set(EXTERNAL_GOOGLEAPIS_PREFIX "${PROJECT_BINARY_DIR}/external/googleapis")
+set(EXTERNAL_GOOGLEAPIS_SOURCE
+    "${EXTERNAL_GOOGLEAPIS_PREFIX}/src/googleapis_download"
+    PARENT_SCOPE)
+set(EXTERNAL_GOOGLEAPIS_SOURCE
+    "${EXTERNAL_GOOGLEAPIS_PREFIX}/src/googleapis_download")
+
+# Include the functions to compile proto files and maintain proto libraries.
+include(CompileProtos)
+
+set(EXTERNAL_GOOGLEAPIS_BYPRODUCTS)
+foreach (proto ${EXTERNAL_GOOGLEAPIS_PROTO_FILES})
+    list(APPEND EXTERNAL_GOOGLEAPIS_BYPRODUCTS
+         "${EXTERNAL_GOOGLEAPIS_SOURCE}/${proto}")
+endforeach ()
+
+file(GLOB protolists "protolists/*.list")
+foreach (file IN LISTS protolists)
+    google_cloud_cpp_load_protolist(protos "${file}")
+    foreach (proto IN LISTS protos)
+        list(APPEND EXTERNAL_GOOGLEAPIS_BYPRODUCTS "${proto}")
+    endforeach ()
+endforeach ()
+
+include(ExternalProject)
+
+# -- The build needs protobuf files. The original build scripts download them from a remote server (see target 'googleapis_download').
+#    This is too unreliable in the context of ClickHouse ... we instead ship the downloaded archive with the ClickHouse source and
+#    extract it into the build directory directly.
+
+# Dummy googleapis_download target. This needs to exist because lots of other targets depend on it
+# We however trick it a little bit saying this target generates the ${EXTERNAL_GOOGLEAPIS_BYPRODUCTS} BYPRODUCTS when
+# actually the following section is the one actually providing such BYPRODUCTS.
+externalproject_add(
+    googleapis_download
+    EXCLUDE_FROM_ALL ON
+    PREFIX "${EXTERNAL_GOOGLEAPIS_PREFIX}"
+    PATCH_COMMAND ""
+    DOWNLOAD_COMMAND ""
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+    BUILD_BYPRODUCTS ${EXTERNAL_GOOGLEAPIS_BYPRODUCTS}
+    LOG_DOWNLOAD OFF)
+
+# Command that extracts the tarball into the proper dir
+# Note: The hash must match the Google Cloud Api version, otherwise funny things will happen.
+# Find the right hash in "strip-prefix" in MODULE.bazel in the subrepository
+message(STATUS "Extracting googleapis tarball")
+set(PB_HASH "e60db19f11f94175ac682c5898cce0f77cc508ea")
+set(PB_ARCHIVE "${PB_HASH}.tar.gz")
+set(PB_DIR "googleapis-${PB_HASH}")
+
+file(ARCHIVE_EXTRACT INPUT
+    "${ClickHouse_SOURCE_DIR}/contrib/google-cloud-cpp-cmake/googleapis/${PB_ARCHIVE}"
+    DESTINATION
+    "${EXTERNAL_GOOGLEAPIS_PREFIX}/tmp")
+
+file(REMOVE_RECURSE "${EXTERNAL_GOOGLEAPIS_SOURCE}")
+file(RENAME
+    "${EXTERNAL_GOOGLEAPIS_PREFIX}/tmp/${PB_DIR}"
+    "${EXTERNAL_GOOGLEAPIS_SOURCE}"
+)
+
+google_cloud_cpp_find_proto_include_dir(PROTO_INCLUDE_DIR)
+
+google_cloud_cpp_add_protos_property()
+
+function (external_googleapis_short_name var proto)
+    string(REPLACE "google/" "" short_name "${proto}")
+    string(REPLACE "/" "_" short_name "${short_name}")
+    string(REPLACE ".proto" "_protos" short_name "${short_name}")
+    set("${var}"
+        "${short_name}"
+        PARENT_SCOPE)
+endfunction ()
+
+# Create a single source proto library.
+#
+# * proto: the filename for the proto source.
+# * (optional) ARGN: proto libraries the new library depends on.
+function (external_googleapis_add_library proto)
+    external_googleapis_short_name(short_name "${proto}")
+    google_cloud_cpp_grpcpp_library(
+        google_cloud_cpp_${short_name} "${EXTERNAL_GOOGLEAPIS_SOURCE}/${proto}"
+        PROTO_PATH_DIRECTORIES "${EXTERNAL_GOOGLEAPIS_SOURCE}"
+        "${PROTO_INCLUDE_DIR}")
+
+    external_googleapis_set_version_and_alias("${short_name}")
+
+    set(public_deps)
+    foreach (dep_short_name ${ARGN})
+        list(APPEND public_deps "google-cloud-cpp::${dep_short_name}")
+    endforeach ()
+    list(LENGTH public_deps public_deps_length)
+    if (public_deps_length EQUAL 0)
+        target_link_libraries("google_cloud_cpp_${short_name}")
+    else ()
+        target_link_libraries("google_cloud_cpp_${short_name}"
+                              PUBLIC ${public_deps})
+    endif ()
+endfunction ()
+
+function (external_googleapis_set_version_and_alias short_name)
+    add_dependencies("google_cloud_cpp_${short_name}" googleapis_download)
+    set_target_properties(
+        "google_cloud_cpp_${short_name}"
+        PROPERTIES EXPORT_NAME google-cloud-cpp::${short_name}
+                   VERSION "${PROJECT_VERSION}"
+                   SOVERSION ${PROJECT_VERSION_MAJOR})
+    add_library("google-cloud-cpp::${short_name}" ALIAS
+                "google_cloud_cpp_${short_name}")
+endfunction ()
+
+if (GOOGLE_CLOUD_CPP_USE_INSTALLED_COMMON)
+    return()
+endif ()
+
+# Avoid adding new proto libraries to this list as these libraries are always
+# installed, regardless of whether or not they are needed. See #8022 for more
+# details.
+set(external_googleapis_installed_libraries_list
+    # cmake-format: sort
+    google_cloud_cpp_cloud_common_common_protos
+    google_cloud_cpp_iam_credentials_v1_common_protos
+    google_cloud_cpp_iam_credentials_v1_iamcredentials_protos
+    google_cloud_cpp_iam_v1_iam_policy_protos
+    google_cloud_cpp_iam_v1_options_protos
+    google_cloud_cpp_iam_v1_policy_protos
+    google_cloud_cpp_longrunning_operations_protos)
+
+# These proto files cannot be added in the foreach() loop because they have
+# dependencies.
+set(PROTO_FILES_WITH_DEPENDENCIES
+    # cmake-format: sort
+    "google/api/annotations.proto"
+    "google/api/auth.proto"
+    "google/api/billing.proto"
+    "google/api/client.proto"
+    "google/api/control.proto"
+    "google/api/distribution.proto"
+    "google/api/endpoint.proto"
+    "google/api/log.proto"
+    "google/api/logging.proto"
+    "google/api/metric.proto"
+    "google/api/monitored_resource.proto"
+    "google/api/monitoring.proto"
+    "google/api/quota.proto"
+    "google/api/service.proto"
+    "google/api/usage.proto"
+    "google/cloud/location/locations.proto"
+    "google/rpc/status.proto")
+
+# For some directories *most* (but not all) the proto files are simple enough
+# that the libraries can be generated with a foreach() loop.
+foreach (proto IN LISTS EXTERNAL_GOOGLEAPIS_PROTO_FILES)
+    if (proto MATCHES "^google/api/"
+        OR proto MATCHES "^google/type"
+        OR proto MATCHES "^google/rpc/"
+        OR proto MATCHES "^google/cloud/")
+        external_googleapis_short_name(short_name "${proto}")
+        list(APPEND external_googleapis_installed_libraries_list
+             google_cloud_cpp_${short_name})
+        list(FIND PROTO_FILES_WITH_DEPENDENCIES "${proto}" has_dependency)
+        if (has_dependency EQUAL -1)
+            external_googleapis_add_library("${proto}")
+        endif ()
+    endif ()
+endforeach ()
+
+# Out of order because they have dependencies.
+external_googleapis_add_library("google/api/annotations.proto" api_http_protos)
+external_googleapis_add_library("google/api/auth.proto" api_annotations_protos)
+external_googleapis_add_library("google/api/client.proto"
+                                api_launch_stage_protos)
+external_googleapis_add_library("google/api/control.proto" api_policy_protos)
+external_googleapis_add_library("google/api/metric.proto"
+                                api_launch_stage_protos api_label_protos)
+external_googleapis_add_library("google/api/billing.proto"
+                                api_annotations_protos api_metric_protos)
+external_googleapis_add_library("google/api/distribution.proto"
+                                api_annotations_protos)
+external_googleapis_add_library("google/api/endpoint.proto"
+                                api_annotations_protos)
+external_googleapis_add_library("google/api/log.proto" api_label_protos)
+external_googleapis_add_library("google/api/logging.proto"
+                                api_annotations_protos api_label_protos)
+external_googleapis_add_library("google/api/monitored_resource.proto"
+                                api_launch_stage_protos api_label_protos)
+external_googleapis_add_library("google/api/monitoring.proto"
+                                api_annotations_protos)
+external_googleapis_add_library("google/api/quota.proto" api_annotations_protos)
+external_googleapis_add_library("google/api/usage.proto" api_annotations_protos
+                                api_visibility_protos)
+external_googleapis_add_library(
+    "google/api/service.proto"
+    api_annotations_protos
+    api_auth_protos
+    api_backend_protos
+    api_billing_protos
+    api_client_protos
+    api_context_protos
+    api_control_protos
+    api_documentation_protos
+    api_endpoint_protos
+    api_http_protos
+    api_label_protos
+    api_log_protos
+    api_logging_protos
+    api_metric_protos
+    api_monitored_resource_protos
+    api_monitoring_protos
+    api_quota_protos
+    api_resource_protos
+    api_source_info_protos
+    api_system_parameter_protos
+    api_usage_protos)
+
+external_googleapis_add_library("google/cloud/location/locations.proto"
+                                api_annotations_protos api_client_protos)
+
+external_googleapis_add_library("google/iam/v1/options.proto"
+                                api_annotations_protos)
+external_googleapis_add_library("google/iam/v1/policy.proto"
+                                api_annotations_protos type_expr_protos)
+external_googleapis_add_library("google/rpc/status.proto"
+                                rpc_error_details_protos)
+
+external_googleapis_add_library(
+    "google/longrunning/operations.proto" api_annotations_protos
+    api_client_protos rpc_status_protos)
+
+external_googleapis_add_library(
+    "google/iam/v1/iam_policy.proto"
+    api_annotations_protos
+    api_client_protos
+    api_field_behavior_protos
+    api_resource_protos
+    iam_v1_options_protos
+    iam_v1_policy_protos)
+
+external_googleapis_add_library("google/iam/credentials/v1/common.proto"
+                                api_field_behavior_protos api_resource_protos)
+
+external_googleapis_add_library(
+    "google/iam/credentials/v1/iamcredentials.proto" api_annotations_protos
+    api_client_protos iam_credentials_v1_common_protos)
+
+google_cloud_cpp_load_protolist(cloud_common_list "${GOOGLE_CLOUD_CPP_DIR}/external/googleapis/protolists/common.list")
+google_cloud_cpp_load_protodeps(cloud_common_deps "${GOOGLE_CLOUD_CPP_DIR}/external/googleapis/protodeps/common.deps")
+google_cloud_cpp_grpcpp_library(
+    google_cloud_cpp_cloud_common_common_protos ${cloud_common_list}
+    PROTO_PATH_DIRECTORIES "${EXTERNAL_GOOGLEAPIS_SOURCE}"
+    "${PROTO_INCLUDE_DIR}")
+external_googleapis_set_version_and_alias(cloud_common_common_protos)
+target_link_libraries(google_cloud_cpp_cloud_common_common_protos
+                      PUBLIC ${cloud_common_deps})
+
+# Install the libraries and headers in the locations determined by
+# GNUInstallDirs
+include(GNUInstallDirs)
+
+install(
+    TARGETS ${external_googleapis_installed_libraries_list}
+    EXPORT googleapis-targets
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+            COMPONENT google_cloud_cpp_runtime
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            COMPONENT google_cloud_cpp_runtime
+            NAMELINK_COMPONENT google_cloud_cpp_development
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            COMPONENT google_cloud_cpp_development)
+
+foreach (target ${external_googleapis_installed_libraries_list})
+    google_cloud_cpp_install_proto_library_headers("${target}")
+    google_cloud_cpp_install_proto_library_protos(
+        "${target}" "${EXTERNAL_GOOGLEAPIS_SOURCE}")
+endforeach ()
+
+# Create and install the pkg-config files.
+foreach (target ${external_googleapis_installed_libraries_list})
+    external_googleapis_install_pc("${target}")
+endforeach ()
+
+# Create and install the googleapis pkg-config file for backwards compatibility.
+set(GOOGLE_CLOUD_CPP_PC_LIBS "")
+google_cloud_cpp_set_pkgconfig_paths()
+set(GOOGLE_CLOUD_CPP_PC_NAME "The Google APIS C++ Proto Library")
+set(GOOGLE_CLOUD_CPP_PC_DESCRIPTION
+    "Provides C++ APIs to access Google Cloud Platforms.")
+# This list is for backwards compatibility purposes only. DO NOT add new
+# libraries to it.
+string(
+    JOIN
+    " "
+    GOOGLE_CLOUD_CPP_PC_REQUIRES
+    "google_cloud_cpp_bigtable_protos"
+    "google_cloud_cpp_cloud_bigquery_protos"
+    "google_cloud_cpp_iam_protos"
+    "google_cloud_cpp_pubsub_protos"
+    "google_cloud_cpp_storage_protos"
+    "google_cloud_cpp_logging_protos"
+    "google_cloud_cpp_iam_v1_iam_policy_protos"
+    "google_cloud_cpp_iam_v1_options_protos"
+    "google_cloud_cpp_iam_v1_policy_protos"
+    "google_cloud_cpp_longrunning_operations_protos"
+    "google_cloud_cpp_api_auth_protos"
+    "google_cloud_cpp_api_annotations_protos"
+    "google_cloud_cpp_api_client_protos"
+    "google_cloud_cpp_api_field_behavior_protos"
+    "google_cloud_cpp_api_http_protos"
+    "google_cloud_cpp_rpc_status_protos"
+    "google_cloud_cpp_rpc_error_details_protos"
+    "google_cloud_cpp_type_expr_protos"
+    "grpc++"
+    "grpc"
+    "openssl"
+    "protobuf"
+    "zlib"
+    "libcares")
+set(GOOGLE_CLOUD_CPP_PC_LIBS "")
+google_cloud_cpp_set_pkgconfig_paths()
+configure_file("${PROJECT_SOURCE_DIR}/cmake/templates/config.pc.in"
+               "googleapis.pc" @ONLY)
+install(
+    FILES "${CMAKE_CURRENT_BINARY_DIR}/googleapis.pc"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
+    COMPONENT google_cloud_cpp_development)
+
+# Create and install the CMake configuration files.
+# include(CMakePackageConfigHelpers)
+
+# configure_file("${CMAKE_CURRENT_LIST_DIR}/config.cmake.in"
+#                "google_cloud_cpp_googleapis-config.cmake" @ONLY)
+# write_basic_package_version_file(
+#     "google_cloud_cpp_googleapis-config-version.cmake"
+#     VERSION ${PROJECT_VERSION}
+#     COMPATIBILITY ExactVersion)
+
+# Export the CMake targets to make it easy to create configuration files.
+# install(
+#     EXPORT googleapis-targets
+#     DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/google_cloud_cpp_googleapis"
+#     COMPONENT google_cloud_cpp_development)
+# install(
+#     FILES
+#         "${CMAKE_CURRENT_BINARY_DIR}/google_cloud_cpp_googleapis-config.cmake"
+#         "${CMAKE_CURRENT_BINARY_DIR}/google_cloud_cpp_googleapis-config-version.cmake"
+#         "${PROJECT_SOURCE_DIR}/cmake/FindgRPC.cmake"
+#         "${PROJECT_SOURCE_DIR}/cmake/CompileProtos.cmake"
+#     DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/google_cloud_cpp_googleapis"
+#     COMPONENT google_cloud_cpp_development)

contrib/google-cloud-cpp-cmake/google_cloud_cpp_common.cmake

@@ -0,0 +1,447 @@
+# ~~~
+# Copyright 2022 Google LLC
+#
+# Licensed 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
+#
+#     https://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.
+# ~~~
+
+# File copied from google-cloud-cpp/google-cloud-cpp/google_cloud_cpp_common.cmake with minor modifications.
+
+set(GOOGLE_CLOUD_CPP_COMMON_DIR "${GOOGLE_CLOUD_CPP_DIR}/google/cloud")
+
+# Generate the version information from the CMake values.
+# configure_file(${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/version_info.h.in
+#                ${CMAKE_CURRENT_SOURCE_DIR}/internal/version_info.h)
+
+# Create the file that captures build information. Having access to the compiler
+# and build flags at runtime allows us to print better benchmark results.
+string(TOUPPER "${CMAKE_BUILD_TYPE}" GOOGLE_CLOUD_CPP_BUILD_TYPE_UPPER)
+configure_file(${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/build_info.cc.in internal/build_info.cc)
+
+# the client library
+add_library(
+    google_cloud_cpp_common # cmake-format: sort
+    ${CMAKE_CURRENT_BINARY_DIR}/internal/build_info.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/access_token.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/access_token.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/backoff_policy.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/common_options.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/credentials.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/credentials.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/experimental_tag.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/future.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/future_generic.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/future_void.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/idempotency.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/absl_str_cat_quiet.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/absl_str_join_quiet.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/absl_str_replace_quiet.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/algorithm.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/api_client_header.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/api_client_header.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/attributes.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/auth_header_error.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/auth_header_error.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/backoff_policy.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/backoff_policy.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/base64_transforms.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/base64_transforms.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/big_endian.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/build_info.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/call_context.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/clock.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/compiler_info.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/compiler_info.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/compute_engine_util.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/compute_engine_util.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/credentials_impl.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/credentials_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/debug_future_status.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/debug_future_status.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/debug_string.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/debug_string.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/detect_gcp.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/detect_gcp_impl.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/detect_gcp_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/diagnostics_pop.inc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/diagnostics_push.inc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/disable_deprecation_warnings.inc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/disable_msvc_crt_secure_warnings.inc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/error_context.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/error_context.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/filesystem.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/filesystem.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/format_time_point.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/format_time_point.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/future_base.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/future_coroutines.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/future_fwd.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/future_impl.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/future_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/future_then_impl.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/future_then_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/getenv.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/getenv.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/group_options.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/invocation_id_generator.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/invocation_id_generator.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/invoke_result.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/ios_flags_saver.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/log_impl.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/log_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/make_status.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/make_status.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/noexcept_action.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/noexcept_action.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/non_constructible.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/opentelemetry.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/opentelemetry.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/opentelemetry_context.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/opentelemetry_context.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/pagination_range.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/parse_rfc3339.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/parse_rfc3339.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/populate_common_options.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/populate_common_options.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/port_platform.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/random.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/random.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/retry_info.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/retry_loop_helpers.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/retry_loop_helpers.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/retry_policy_impl.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/retry_policy_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/service_endpoint.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/service_endpoint.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/sha256_hash.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/sha256_hash.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/sha256_hmac.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/sha256_hmac.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/sha256_type.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/status_payload_keys.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/status_payload_keys.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/status_utils.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/status_utils.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/strerror.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/strerror.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/subject_token.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/subject_token.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/throw_delegate.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/throw_delegate.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/timer_queue.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/timer_queue.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/trace_propagator.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/trace_propagator.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/traced_stream_range.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/tuple.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/type_list.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/type_traits.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/url_encode.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/url_encode.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/user_agent_prefix.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/user_agent_prefix.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/utility.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/version_info.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/kms_key_name.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/kms_key_name.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/location.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/location.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/log.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/log.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/no_await_tag.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/opentelemetry_options.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/optional.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/options.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/options.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/polling_policy.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/project.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/project.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/retry_policy.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/rpc_metadata.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/status.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/status.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/status_or.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/stream_range.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/terminate_handler.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/terminate_handler.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/tracing_options.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/tracing_options.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/universe_domain_options.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/version.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/version.h)
+target_link_libraries(
+    google_cloud_cpp_common
+    PUBLIC absl::base
+           absl::memory
+           absl::optional
+           absl::span
+           absl::str_format
+           absl::time
+           absl::variant
+           Threads::Threads)
+if (WIN32)
+    target_compile_definitions(google_cloud_cpp_common
+                               PRIVATE WIN32_LEAN_AND_MEAN)
+    target_link_libraries(google_cloud_cpp_common PUBLIC bcrypt)
+else ()
+    target_link_libraries(google_cloud_cpp_common PUBLIC OpenSSL::Crypto ch_contrib::re2)
+endif ()
+
+google_cloud_cpp_add_common_options(google_cloud_cpp_common)
+target_include_directories(
+    google_cloud_cpp_common PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
+                                   $<INSTALL_INTERFACE:include>)
+
+# We're putting generated code into ${PROJECT_BINARY_DIR} (e.g. compiled
+# protobufs or build info), so we need it on the include path, however we don't
+# want it checked by linters so we mark it as SYSTEM.
+target_include_directories(google_cloud_cpp_common SYSTEM
+                           PUBLIC $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>)
+target_compile_options(google_cloud_cpp_common
+                       PUBLIC ${GOOGLE_CLOUD_CPP_EXCEPTIONS_FLAG})
+
+set_target_properties(
+    google_cloud_cpp_common
+    PROPERTIES EXPORT_NAME "google-cloud-cpp::common"
+               VERSION ${PROJECT_VERSION}
+               SOVERSION ${PROJECT_VERSION_MAJOR})
+add_library(google-cloud-cpp::common ALIAS google_cloud_cpp_common)
+
+#create_bazel_config(google_cloud_cpp_common YEAR 2018)
+
+# # Export the CMake targets to make it easy to create configuration files.
+# install(
+#     EXPORT google_cloud_cpp_common-targets
+#     DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/google_cloud_cpp_common"
+#     COMPONENT google_cloud_cpp_development)
+
+# # Install the libraries and headers in the locations determined by
+# # GNUInstallDirs
+# install(
+#     TARGETS google_cloud_cpp_common
+#     EXPORT google_cloud_cpp_common-targets
+#     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+#             COMPONENT google_cloud_cpp_runtime
+#     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+#             COMPONENT google_cloud_cpp_runtime
+#             NAMELINK_COMPONENT google_cloud_cpp_development
+#     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+#             COMPONENT google_cloud_cpp_development)
+
+#google_cloud_cpp_install_headers(google_cloud_cpp_common include/google/cloud)
+
+# google_cloud_cpp_add_pkgconfig(
+#     "common"
+#     "Google Cloud C++ Client Library Common Components"
+#     "Common Components used by the Google Cloud C++ Client Libraries."
+#     "absl_optional"
+#     "absl_span"
+#     "absl_strings"
+#     "absl_time"
+#     "absl_time_zone"
+#     "absl_variant"
+#     "${GOOGLE_CLOUD_CPP_OPENTELEMETRY_API}"
+#     NON_WIN32_REQUIRES
+#     openssl
+#     WIN32_LIBS
+#     bcrypt)
+
+# Create and install the CMake configuration files.
+# configure_file("config.cmake.in" "google_cloud_cpp_common-config.cmake" @ONLY)
+# write_basic_package_version_file(
+#     "google_cloud_cpp_common-config-version.cmake"
+#     VERSION ${PROJECT_VERSION}
+#     COMPATIBILITY ExactVersion)
+
+# install(
+#     FILES
+#         "${CMAKE_CURRENT_BINARY_DIR}/google_cloud_cpp_common-config.cmake"
+#         "${CMAKE_CURRENT_BINARY_DIR}/google_cloud_cpp_common-config-version.cmake"
+#     DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/google_cloud_cpp_common"
+#     COMPONENT google_cloud_cpp_development)
+
+# if (GOOGLE_CLOUD_CPP_WITH_MOCKS)
+#     # Create a header-only library for the mocks. We use a CMake `INTERFACE`
+#     # library for these, a regular library would not work on macOS (where the
+#     # library needs at least one .o file).
+#     add_library(google_cloud_cpp_mocks INTERFACE)
+#     set(google_cloud_cpp_mocks_hdrs
+#         # cmake-format: sort
+#         mocks/current_options.h mocks/mock_async_streaming_read_write_rpc.h
+#         mocks/mock_stream_range.h)
+#     export_list_to_bazel("google_cloud_cpp_mocks.bzl"
+#                          "google_cloud_cpp_mocks_hdrs" YEAR "2022")
+#     target_link_libraries(
+#         google_cloud_cpp_mocks INTERFACE google-cloud-cpp::common GTest::gmock
+#                                          GTest::gtest)
+#     set_target_properties(google_cloud_cpp_mocks
+#                           PROPERTIES EXPORT_NAME google-cloud-cpp::mocks)
+#     target_include_directories(
+#         google_cloud_cpp_mocks
+#         INTERFACE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
+#                   $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>
+#                   $<INSTALL_INTERFACE:include>)
+#     target_compile_options(google_cloud_cpp_mocks
+#                            INTERFACE ${GOOGLE_CLOUD_CPP_EXCEPTIONS_FLAG})
+#     add_library(google-cloud-cpp::mocks ALIAS google_cloud_cpp_mocks)
+
+#     install(
+#         FILES ${google_cloud_cpp_mocks_hdrs}
+#         DESTINATION "include/google/cloud/mocks"
+#         COMPONENT google_cloud_cpp_development)
+
+#     # Export the CMake targets to make it easy to create configuration files.
+#     install(
+#         EXPORT google_cloud_cpp_mocks-targets
+#         DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/google_cloud_cpp_mocks"
+#         COMPONENT google_cloud_cpp_development)
+
+#     install(
+#         TARGETS google_cloud_cpp_mocks
+#         EXPORT google_cloud_cpp_mocks-targets
+#         COMPONENT google_cloud_cpp_development)
+
+#     google_cloud_cpp_add_pkgconfig(
+#         "mocks" "Google Cloud C++ Testing Library"
+#         "Helpers for testing the Google Cloud C++ Client Libraries"
+#         "google_cloud_cpp_common" "gmock")
+
+#     # Create and install the CMake configuration files.
+#     configure_file("mocks-config.cmake.in"
+#                    "google_cloud_cpp_mocks-config.cmake" @ONLY)
+#     write_basic_package_version_file(
+#         "google_cloud_cpp_mocks-config-version.cmake"
+#         VERSION ${PROJECT_VERSION}
+#         COMPATIBILITY ExactVersion)
+
+#     install(
+#         FILES
+#             "${CMAKE_CURRENT_BINARY_DIR}/google_cloud_cpp_mocks-config.cmake"
+#             "${CMAKE_CURRENT_BINARY_DIR}/google_cloud_cpp_mocks-config-version.cmake"
+#         DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/google_cloud_cpp_mocks"
+#         COMPONENT google_cloud_cpp_development)
+# endif ()
+
+# if (BUILD_TESTING)
+#     include(FindBenchmarkWithWorkarounds)
+
+#     set(google_cloud_cpp_common_unit_tests
+#         # cmake-format: sort
+#         access_token_test.cc
+#         common_options_test.cc
+#         future_coroutines_test.cc
+#         future_generic_test.cc
+#         future_generic_then_test.cc
+#         future_void_test.cc
+#         future_void_then_test.cc
+#         internal/algorithm_test.cc
+#         internal/api_client_header_test.cc
+#         internal/backoff_policy_test.cc
+#         internal/base64_transforms_test.cc
+#         internal/big_endian_test.cc
+#         internal/call_context_test.cc
+#         internal/clock_test.cc
+#         internal/compiler_info_test.cc
+#         internal/compute_engine_util_test.cc
+#         internal/credentials_impl_test.cc
+#         internal/debug_future_status_test.cc
+#         internal/debug_string_test.cc
+#         internal/detect_gcp_test.cc
+#         internal/error_context_test.cc
+#         internal/filesystem_test.cc
+#         internal/format_time_point_test.cc
+#         internal/future_impl_test.cc
+#         internal/future_then_impl_test.cc
+#         internal/group_options_test.cc
+#         internal/invocation_id_generator_test.cc
+#         internal/invoke_result_test.cc
+#         internal/log_impl_test.cc
+#         internal/make_status_test.cc
+#         internal/noexcept_action_test.cc
+#         internal/opentelemetry_context_test.cc
+#         internal/opentelemetry_test.cc
+#         internal/pagination_range_test.cc
+#         internal/parse_rfc3339_test.cc
+#         internal/populate_common_options_test.cc
+#         internal/random_test.cc
+#         internal/retry_loop_helpers_test.cc
+#         internal/retry_policy_impl_test.cc
+#         internal/service_endpoint_test.cc
+#         internal/sha256_hash_test.cc
+#         internal/sha256_hmac_test.cc
+#         internal/status_payload_keys_test.cc
+#         internal/status_utils_test.cc
+#         internal/strerror_test.cc
+#         internal/subject_token_test.cc
+#         internal/throw_delegate_test.cc
+#         internal/timer_queue_test.cc
+#         internal/trace_propagator_test.cc
+#         internal/traced_stream_range_test.cc
+#         internal/tuple_test.cc
+#         internal/type_list_test.cc
+#         internal/url_encode_test.cc
+#         internal/user_agent_prefix_test.cc
+#         internal/utility_test.cc
+#         kms_key_name_test.cc
+#         location_test.cc
+#         log_test.cc
+#         mocks/current_options_test.cc
+#         mocks/mock_stream_range_test.cc
+#         options_test.cc
+#         polling_policy_test.cc
+#         project_test.cc
+#         status_or_test.cc
+#         status_test.cc
+#         stream_range_test.cc
+#         terminate_handler_test.cc
+#         tracing_options_test.cc)
+
+#     # Export the list of unit tests so the Bazel BUILD file can pick it up.
+#     export_list_to_bazel("google_cloud_cpp_common_unit_tests.bzl"
+#                          "google_cloud_cpp_common_unit_tests" YEAR "2018")
+
+#     foreach (fname ${google_cloud_cpp_common_unit_tests})
+#         google_cloud_cpp_add_executable(target "common" "${fname}")
+#         target_link_libraries(
+#             ${target}
+#             PRIVATE google_cloud_cpp_testing
+#                     google-cloud-cpp::common
+#                     google-cloud-cpp::mocks
+#                     absl::variant
+#                     GTest::gmock_main
+#                     GTest::gmock
+#                     GTest::gtest)
+#         google_cloud_cpp_add_common_options(${target})
+#         add_test(NAME ${target} COMMAND ${target})
+#     endforeach ()
+
+#     set(google_cloud_cpp_common_benchmarks # cmake-format: sort
+#                                            options_benchmark.cc)
+
+#     # Export the list of benchmarks to a .bzl file so we do not need to maintain
+#     # the list in two places.
+#     export_list_to_bazel("google_cloud_cpp_common_benchmarks.bzl"
+#                          "google_cloud_cpp_common_benchmarks" YEAR "2020")
+
+#     # Generate a target for each benchmark.
+#     foreach (fname ${google_cloud_cpp_common_benchmarks})
+#         google_cloud_cpp_add_executable(target "common" "${fname}")
+#         add_test(NAME ${target} COMMAND ${target})
+#         target_link_libraries(${target} PRIVATE google-cloud-cpp::common
+#                                                 benchmark::benchmark_main)
+#         google_cloud_cpp_add_common_options(${target})
+#     endforeach ()
+# endif ()
+
+# if (BUILD_TESTING AND GOOGLE_CLOUD_CPP_ENABLE_CXX_EXCEPTIONS)
+#     google_cloud_cpp_add_samples_relative("common" "samples/")
+# endif ()

contrib/google-cloud-cpp-cmake/google_cloud_cpp_grpc_utils.cmake

@@ -0,0 +1,350 @@
+# ~~~
+# Copyright 2022 Google LLC
+#
+# Licensed 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
+#
+#     https://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.
+# ~~~
+
+# File copied from google-cloud-cpp/google-cloud-cpp/google_cloud_cpp_grpc_utils.cmake with minor modifications.
+
+set(GOOGLE_CLOUD_CPP_COMMON_DIR "${GOOGLE_CLOUD_CPP_DIR}/google/cloud")
+
+# the library
+add_library(
+    google_cloud_cpp_grpc_utils # cmake-format: sort
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/async_operation.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/async_streaming_read_write_rpc.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/background_threads.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/completion_queue.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/completion_queue.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/connection_options.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/connection_options.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/grpc_error_delegate.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/grpc_error_delegate.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/grpc_options.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/grpc_options.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/grpc_utils/async_operation.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/grpc_utils/completion_queue.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/grpc_utils/grpc_error_delegate.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/grpc_utils/version.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/iam_updater.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_connection_ready.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_connection_ready.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_long_running_operation.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_polling_loop.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_polling_loop.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_read_stream_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_read_write_stream_auth.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_read_write_stream_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_read_write_stream_logging.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_read_write_stream_timeout.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_read_write_stream_tracing.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_retry_loop.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_retry_unary_rpc.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_rpc_details.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_streaming_read_rpc.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_streaming_read_rpc_auth.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_streaming_read_rpc_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_streaming_read_rpc_logging.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_streaming_read_rpc_timeout.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_streaming_read_rpc_tracing.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_streaming_write_rpc.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_streaming_write_rpc_auth.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_streaming_write_rpc_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_streaming_write_rpc_logging.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_streaming_write_rpc_timeout.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/async_streaming_write_rpc_tracing.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/background_threads_impl.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/background_threads_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/completion_queue_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/debug_string_protobuf.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/debug_string_protobuf.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/debug_string_status.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/debug_string_status.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/default_completion_queue_impl.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/default_completion_queue_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/extract_long_running_result.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/extract_long_running_result.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_access_token_authentication.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_access_token_authentication.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_api_key_authentication.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_api_key_authentication.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_async_access_token_cache.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_async_access_token_cache.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_channel_credentials_authentication.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_channel_credentials_authentication.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_impersonate_service_account.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_impersonate_service_account.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_metadata_view.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_opentelemetry.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_opentelemetry.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_request_metadata.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_request_metadata.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_service_account_authentication.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/grpc_service_account_authentication.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/log_wrapper.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/log_wrapper.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/minimal_iam_credentials_stub.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/minimal_iam_credentials_stub.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/populate_grpc_options.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/populate_grpc_options.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/resumable_streaming_read_rpc.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/retry_loop.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/routing_matcher.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/setup_context.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/streaming_read_rpc.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/streaming_read_rpc.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/streaming_read_rpc_logging.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/streaming_read_rpc_tracing.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/streaming_write_rpc.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/streaming_write_rpc_impl.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/streaming_write_rpc_impl.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/streaming_write_rpc_logging.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/streaming_write_rpc_tracing.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/time_utils.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/time_utils.h
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/unified_grpc_credentials.cc
+    ${GOOGLE_CLOUD_CPP_COMMON_DIR}/internal/unified_grpc_credentials.h)
+target_link_libraries(
+    google_cloud_cpp_grpc_utils
+    PUBLIC absl::function_ref
+           absl::memory
+           absl::time
+           absl::variant
+           google-cloud-cpp::iam_credentials_v1_iamcredentials_protos
+           google-cloud-cpp::iam_v1_policy_protos
+           google-cloud-cpp::longrunning_operations_protos
+           google-cloud-cpp::iam_v1_iam_policy_protos
+           google-cloud-cpp::rpc_error_details_protos
+           google-cloud-cpp::rpc_status_protos
+           google-cloud-cpp::common
+           gRPC::grpc++
+           gRPC::grpc)
+google_cloud_cpp_add_common_options(google_cloud_cpp_grpc_utils)
+target_include_directories(
+    google_cloud_cpp_grpc_utils PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
+                                       $<INSTALL_INTERFACE:include>)
+target_compile_options(google_cloud_cpp_grpc_utils
+                       PUBLIC ${GOOGLE_CLOUD_CPP_EXCEPTIONS_FLAG})
+set_target_properties(
+    google_cloud_cpp_grpc_utils
+    PROPERTIES EXPORT_NAME "google-cloud-cpp::grpc_utils"
+               VERSION ${PROJECT_VERSION}
+               SOVERSION ${PROJECT_VERSION_MAJOR})
+add_library(google-cloud-cpp::grpc_utils ALIAS google_cloud_cpp_grpc_utils)
+
+#create_bazel_config(google_cloud_cpp_grpc_utils YEAR 2019)
+
+# # Install the libraries and headers in the locations determined by
+# # GNUInstallDirs
+# install(
+#     TARGETS
+#     EXPORT grpc_utils-targets
+#     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+#     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+#     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+#             COMPONENT google_cloud_cpp_development)
+
+# # Export the CMake targets to make it easy to create configuration files.
+# install(
+#     EXPORT grpc_utils-targets
+#     DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/google_cloud_cpp_grpc_utils"
+#     COMPONENT google_cloud_cpp_development)
+
+# install(
+#     TARGETS google_cloud_cpp_grpc_utils
+#     EXPORT grpc_utils-targets
+#     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+#             COMPONENT google_cloud_cpp_runtime
+#     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+#             COMPONENT google_cloud_cpp_runtime
+#             NAMELINK_COMPONENT google_cloud_cpp_development
+#     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+#             COMPONENT google_cloud_cpp_development)
+
+# google_cloud_cpp_install_headers(google_cloud_cpp_grpc_utils
+#                                  include/google/cloud)
+
+# google_cloud_cpp_add_pkgconfig(
+#     grpc_utils
+#     "gRPC Utilities for the Google Cloud C++ Client Library"
+#     "Provides gRPC Utilities for the Google Cloud C++ Client Library."
+#     "google_cloud_cpp_common"
+#     "google_cloud_cpp_iam_credentials_v1_iamcredentials_protos"
+#     "google_cloud_cpp_iam_v1_policy_protos"
+#     "google_cloud_cpp_iam_v1_iam_policy_protos"
+#     "google_cloud_cpp_longrunning_operations_protos"
+#     "google_cloud_cpp_rpc_status_protos"
+#     "absl_function_ref"
+#     "absl_strings"
+#     "absl_time"
+#     "absl_time_zone"
+#     "absl_variant"
+#     "openssl")
+
+# # Create and install the CMake configuration files.
+# configure_file("grpc_utils/config.cmake.in"
+#                "google_cloud_cpp_grpc_utils-config.cmake" @ONLY)
+# write_basic_package_version_file(
+#     "google_cloud_cpp_grpc_utils-config-version.cmake"
+#     VERSION ${PROJECT_VERSION}
+#     COMPATIBILITY ExactVersion)
+
+# install(
+#     FILES
+#         "${CMAKE_CURRENT_BINARY_DIR}/google_cloud_cpp_grpc_utils-config.cmake"
+#         "${CMAKE_CURRENT_BINARY_DIR}/google_cloud_cpp_grpc_utils-config-version.cmake"
+#     DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/google_cloud_cpp_grpc_utils"
+#     COMPONENT google_cloud_cpp_development)
+
+# function (google_cloud_cpp_grpc_utils_add_test fname labels)
+#     google_cloud_cpp_add_executable(target "common" "${fname}")
+#     target_link_libraries(
+#         ${target}
+#         PRIVATE google-cloud-cpp::grpc_utils
+#                 google_cloud_cpp_testing_grpc
+#                 google_cloud_cpp_testing
+#                 google-cloud-cpp::common
+#                 absl::variant
+#                 GTest::gmock_main
+#                 GTest::gmock
+#                 GTest::gtest
+#                 gRPC::grpc++
+#                 gRPC::grpc)
+#     google_cloud_cpp_add_common_options(${target})
+#     add_test(NAME ${target} COMMAND ${target})
+#     set_tests_properties(${target} PROPERTIES LABELS "${labels}")
+# endfunction ()
+
+# if (BUILD_TESTING)
+#     include(FindBenchmarkWithWorkarounds)
+
+#     # List the unit tests, then setup the targets and dependencies.
+#     set(google_cloud_cpp_grpc_utils_unit_tests
+#         # cmake-format: sort
+#         completion_queue_test.cc
+#         connection_options_test.cc
+#         grpc_error_delegate_test.cc
+#         grpc_options_test.cc
+#         internal/async_connection_ready_test.cc
+#         internal/async_long_running_operation_test.cc
+#         internal/async_polling_loop_test.cc
+#         internal/async_read_write_stream_auth_test.cc
+#         internal/async_read_write_stream_impl_test.cc
+#         internal/async_read_write_stream_logging_test.cc
+#         internal/async_read_write_stream_timeout_test.cc
+#         internal/async_read_write_stream_tracing_test.cc
+#         internal/async_retry_loop_test.cc
+#         internal/async_retry_unary_rpc_test.cc
+#         internal/async_streaming_read_rpc_auth_test.cc
+#         internal/async_streaming_read_rpc_impl_test.cc
+#         internal/async_streaming_read_rpc_logging_test.cc
+#         internal/async_streaming_read_rpc_timeout_test.cc
+#         internal/async_streaming_read_rpc_tracing_test.cc
+#         internal/async_streaming_write_rpc_auth_test.cc
+#         internal/async_streaming_write_rpc_impl_test.cc
+#         internal/async_streaming_write_rpc_logging_test.cc
+#         internal/async_streaming_write_rpc_timeout_test.cc
+#         internal/async_streaming_write_rpc_tracing_test.cc
+#         internal/background_threads_impl_test.cc
+#         internal/debug_string_protobuf_test.cc
+#         internal/debug_string_status_test.cc
+#         internal/extract_long_running_result_test.cc
+#         internal/grpc_access_token_authentication_test.cc
+#         internal/grpc_async_access_token_cache_test.cc
+#         internal/grpc_channel_credentials_authentication_test.cc
+#         internal/grpc_opentelemetry_test.cc
+#         internal/grpc_request_metadata_test.cc
+#         internal/grpc_service_account_authentication_test.cc
+#         internal/log_wrapper_test.cc
+#         internal/minimal_iam_credentials_stub_test.cc
+#         internal/populate_grpc_options_test.cc
+#         internal/resumable_streaming_read_rpc_test.cc
+#         internal/retry_loop_test.cc
+#         internal/routing_matcher_test.cc
+#         internal/streaming_read_rpc_logging_test.cc
+#         internal/streaming_read_rpc_test.cc
+#         internal/streaming_read_rpc_tracing_test.cc
+#         internal/streaming_write_rpc_logging_test.cc
+#         internal/streaming_write_rpc_test.cc
+#         internal/streaming_write_rpc_tracing_test.cc
+#         internal/time_utils_test.cc
+#         internal/unified_grpc_credentials_test.cc)
+
+#     # List the unit tests, then setup the targets and dependencies.
+#     set(google_cloud_cpp_grpc_utils_integration_tests
+#         # cmake-format: sort
+#         internal/grpc_impersonate_service_account_integration_test.cc)
+
+#     # Export the list of unit and integration tests so the Bazel BUILD file can
+#     # pick them up.
+#     export_list_to_bazel("google_cloud_cpp_grpc_utils_unit_tests.bzl"
+#                          "google_cloud_cpp_grpc_utils_unit_tests" YEAR "2019")
+#     export_list_to_bazel(
+#         "google_cloud_cpp_grpc_utils_integration_tests.bzl"
+#         "google_cloud_cpp_grpc_utils_integration_tests" YEAR "2021")
+
+#     foreach (fname ${google_cloud_cpp_grpc_utils_unit_tests})
+#         google_cloud_cpp_grpc_utils_add_test("${fname}" "")
+#     endforeach ()
+
+#     # TODO(#12485) - remove dependency on bigtable in this integration test.
+#     if (NOT bigtable IN_LIST GOOGLE_CLOUD_CPP_ENABLE)
+#         list(REMOVE_ITEM google_cloud_cpp_grpc_utils_integration_tests
+#              "internal/grpc_impersonate_service_account_integration_test.cc")
+#     endif ()
+
+#     foreach (fname ${google_cloud_cpp_grpc_utils_integration_tests})
+#         google_cloud_cpp_add_executable(target "common" "${fname}")
+#         target_link_libraries(
+#             ${target}
+#             PRIVATE google-cloud-cpp::grpc_utils
+#                     google_cloud_cpp_testing_grpc
+#                     google_cloud_cpp_testing
+#                     google-cloud-cpp::common
+#                     google-cloud-cpp::iam_credentials_v1_iamcredentials_protos
+#                     absl::variant
+#                     GTest::gmock_main
+#                     GTest::gmock
+#                     GTest::gtest
+#                     gRPC::grpc++
+#                     gRPC::grpc)
+#         google_cloud_cpp_add_common_options(${target})
+#         add_test(NAME ${target} COMMAND ${target})
+#         set_tests_properties(${target} PROPERTIES LABELS
+#                                                   "integration-test-production")
+#         # TODO(12485) - remove dep on bigtable_protos
+#         if (bigtable IN_LIST GOOGLE_CLOUD_CPP_ENABLE)
+#             target_link_libraries(${target}
+#                                   PRIVATE google-cloud-cpp::bigtable_protos)
+#         endif ()
+#     endforeach ()
+
+#     set(google_cloud_cpp_grpc_utils_benchmarks # cmake-format: sortable
+#                                                completion_queue_benchmark.cc)
+
+#     # Export the list of benchmarks to a .bzl file so we do not need to maintain
+#     # the list in two places.
+#     export_list_to_bazel("google_cloud_cpp_grpc_utils_benchmarks.bzl"
+#                          "google_cloud_cpp_grpc_utils_benchmarks" YEAR "2020")
+
+#     # Generate a target for each benchmark.
+#     foreach (fname ${google_cloud_cpp_grpc_utils_benchmarks})
+#         google_cloud_cpp_add_executable(target "common" "${fname}")
+#         add_test(NAME ${target} COMMAND ${target})
+#         target_link_libraries(
+#             ${target}
+#             PRIVATE google-cloud-cpp::grpc_utils google-cloud-cpp::common
+#                     benchmark::benchmark_main)
+#         google_cloud_cpp_add_common_options(${target})
+#     endforeach ()
+# endif ()

contrib/update-submodules.sh

@@ -24,7 +24,7 @@ git config --file .gitmodules --get-regexp '.*path' | sed 's/[^ ]* //' | xargs -
 # We don't want to depend on any third-party CMake files.
 # To check it, find and delete them.
 grep -o -P '"contrib/[^"]+"' .gitmodules |
-  grep -v -P 'contrib/(llvm-project|google-protobuf|grpc|abseil-cpp|corrosion|aws-crt-cpp)' |
+  grep -v -P 'contrib/(llvm-project|google-protobuf|grpc|abseil-cpp|corrosion|aws-crt-cpp|google-cloud-cpp)' |
   xargs -I@ find @ \
     -'(' -name 'CMakeLists.txt' -or -name '*.cmake' -')' -and -not -name '*.h.cmake' \
     -delete

docs/en/engines/table-engines/integrations/s3.md

@@ -258,7 +258,7 @@ CREATE TABLE table_with_asterisk (name String, value UInt32)
 
 - [s3_truncate_on_insert](/docs/en/operations/settings/settings.md#s3_truncate_on_insert) - allows to truncate file before insert into it. Disabled by default.
 - [s3_create_new_file_on_insert](/docs/en/operations/settings/settings.md#s3_create_new_file_on_insert) - allows to create a new file on each insert if format has suffix. Disabled by default.
-- [s3_skip_empty_files](/docs/en/operations/settings/settings.md#s3_skip_empty_files) - allows to skip empty files while reading. Disabled by default.
+- [s3_skip_empty_files](/docs/en/operations/settings/settings.md#s3_skip_empty_files) - allows to skip empty files while reading. Enabled by default.
 
 ## S3-related Settings {#settings}
 

docs/en/sql-reference/functions/array-functions.md

@@ -2121,16 +2121,18 @@ Result:
 ```
 
 
-## arrayAUC
+## arrayRocAUC
 
-Calculate AUC (Area Under the Curve, which is a concept in machine learning, see more details: <https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve>).
+Calculate AUC (Area Under the Curve) for the Receiver Operating Characteristic (ROC) curve. The AUC is a concept in machine learning, see more details: <https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve>.
 
 **Syntax**
 
 ``` sql
-arrayAUC(arr_scores, arr_labels[, scale])
+arrayRocAUC(arr_scores, arr_labels[, scale])
 ```
 
+Alias: `arrayAUC`
+
 **Arguments**
 
 - `arr_scores` — scores prediction model gives.
@@ -2139,22 +2141,22 @@ arrayAUC(arr_scores, arr_labels[, scale])
 
 **Returned value**
 
-Returns AUC value with type Float64.
+Returns ROC AUC value with type Float64.
 
 **Example**
 
 Query:
 
 ``` sql
-select arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
+select arrayRocAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
 ```
 
 Result:
 
 ``` text
-┌─arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
-│                                          0.75 │
-└───────────────────────────────────────────────┘
+┌─arrayRocAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
+│                                             0.75 │
+└──────────────────────────────────────────────────┘
 ```
 
 ## arrayMap(func, arr1, ...)

docs/en/sql-reference/table-functions/deltalake.md

@@ -49,4 +49,4 @@ LIMIT 2
 **See Also**
 
 - [DeltaLake engine](/docs/en/engines/table-engines/integrations/deltalake.md)
-
+- [DeltaLake cluster table function](/docs/en/sql-reference/table-functions/deltalakeCluster.md)

docs/en/sql-reference/table-functions/deltalakeCluster.md

@@ -0,0 +1,30 @@
+---
+slug: /en/sql-reference/table-functions/deltalakeCluster
+sidebar_position: 46
+sidebar_label: deltaLakeCluster
+title: "deltaLakeCluster Table Function"
+---
+This is an extension to the [deltaLake](/docs/en/sql-reference/table-functions/deltalake.md) table function.
+
+Allows processing files from [Delta Lake](https://github.com/delta-io/delta) tables in Amazon S3 in parallel from many nodes in a specified cluster. On initiator it creates a connection to all nodes in the cluster and dispatches each file dynamically. On the worker node it asks the initiator about the next task to process and processes it. This is repeated until all tasks are finished.
+
+**Syntax**
+
+``` sql
+deltaLakeCluster(cluster_name, url [,aws_access_key_id, aws_secret_access_key] [,format] [,structure] [,compression])
+```
+
+**Arguments**
+
+- `cluster_name` — Name of a cluster that is used to build a set of addresses and connection parameters to remote and local servers.
+
+- Description of all other arguments coincides with description of arguments in equivalent [deltaLake](/docs/en/sql-reference/table-functions/deltalake.md) table function.
+
+**Returned value**
+
+A table with the specified structure for reading data from cluster in the specified Delta Lake table in S3.
+
+**See Also**
+
+- [deltaLake engine](/docs/en/engines/table-engines/integrations/deltalake.md)
+- [deltaLake table function](/docs/en/sql-reference/table-functions/deltalake.md)

docs/en/sql-reference/table-functions/hudi.md

@@ -29,4 +29,4 @@ A table with the specified structure for reading data in the specified Hudi tabl
 **See Also**
 
 - [Hudi engine](/docs/en/engines/table-engines/integrations/hudi.md)
-
+- [Hudi cluster table function](/docs/en/sql-reference/table-functions/hudiCluster.md)

docs/en/sql-reference/table-functions/hudiCluster.md

@@ -0,0 +1,30 @@
+---
+slug: /en/sql-reference/table-functions/hudiCluster
+sidebar_position: 86
+sidebar_label: hudiCluster
+title: "hudiCluster Table Function"
+---
+This is an extension to the [hudi](/docs/en/sql-reference/table-functions/hudi.md) table function.
+
+Allows processing files from Apache [Hudi](https://hudi.apache.org/) tables in Amazon S3 in parallel from many nodes in a specified cluster. On initiator it creates a connection to all nodes in the cluster and dispatches each file dynamically. On the worker node it asks the initiator about the next task to process and processes it. This is repeated until all tasks are finished.
+
+**Syntax**
+
+``` sql
+hudiCluster(cluster_name, url [,aws_access_key_id, aws_secret_access_key] [,format] [,structure] [,compression])
+```
+
+**Arguments**
+
+- `cluster_name` — Name of a cluster that is used to build a set of addresses and connection parameters to remote and local servers.
+
+- Description of all other arguments coincides with description of arguments in equivalent [hudi](/docs/en/sql-reference/table-functions/hudi.md) table function.
+
+**Returned value**
+
+A table with the specified structure for reading data from cluster in the specified Hudi table in S3.
+
+**See Also**
+
+- [Hudi engine](/docs/en/engines/table-engines/integrations/hudi.md)
+- [Hudi table function](/docs/en/sql-reference/table-functions/hudi.md)

docs/en/sql-reference/table-functions/iceberg.md

@@ -72,3 +72,4 @@ Table function `iceberg` is an alias to `icebergS3` now.
 **See Also**
 
 - [Iceberg engine](/docs/en/engines/table-engines/integrations/iceberg.md)
+- [Iceberg cluster table function](/docs/en/sql-reference/table-functions/icebergCluster.md)

docs/en/sql-reference/table-functions/icebergCluster.md

@@ -0,0 +1,43 @@
+---
+slug: /en/sql-reference/table-functions/icebergCluster
+sidebar_position: 91
+sidebar_label: icebergCluster
+title: "icebergCluster Table Function"
+---
+This is an extension to the [iceberg](/docs/en/sql-reference/table-functions/iceberg.md) table function.
+
+Allows processing files from Apache [Iceberg](https://iceberg.apache.org/) in parallel from many nodes in a specified cluster. On initiator it creates a connection to all nodes in the cluster and dispatches each file dynamically. On the worker node it asks the initiator about the next task to process and processes it. This is repeated until all tasks are finished.
+
+**Syntax**
+
+``` sql
+icebergS3Cluster(cluster_name, url [, NOSIGN | access_key_id, secret_access_key, [session_token]] [,format] [,compression_method])
+icebergS3Cluster(cluster_name, named_collection[, option=value [,..]])
+
+icebergAzureCluster(cluster_name, connection_string|storage_account_url, container_name, blobpath, [,account_name], [,account_key] [,format] [,compression_method])
+icebergAzureCluster(cluster_name, named_collection[, option=value [,..]])
+
+icebergHDFSCluster(cluster_name, path_to_table, [,format] [,compression_method])
+icebergHDFSCluster(cluster_name, named_collection[, option=value [,..]])
+```
+
+**Arguments**
+
+- `cluster_name` — Name of a cluster that is used to build a set of addresses and connection parameters to remote and local servers.
+
+- Description of all other arguments coincides with description of arguments in equivalent [iceberg](/docs/en/sql-reference/table-functions/iceberg.md) table function.
+
+**Returned value**
+
+A table with the specified structure for reading data from cluster in the specified Iceberg table.
+
+**Examples**
+
+```sql
+SELECT * FROM icebergS3Cluster('cluster_simple', 'http://test.s3.amazonaws.com/clickhouse-bucket/test_table', 'test', 'test')
+```
+
+**See Also**
+
+- [Iceberg engine](/docs/en/engines/table-engines/integrations/iceberg.md)
+- [Iceberg table function](/docs/en/sql-reference/table-functions/iceberg.md)

docs/en/sql-reference/table-functions/s3.md

@@ -317,7 +317,7 @@ SELECT * from s3('s3://data/path/date=*/country=*/code=*/*.parquet') where _date
 
 - [s3_truncate_on_insert](/docs/en/operations/settings/settings.md#s3_truncate_on_insert) - allows to truncate file before insert into it. Disabled by default.
 - [s3_create_new_file_on_insert](/docs/en/operations/settings/settings.md#s3_create_new_file_on_insert) - allows to create a new file on each insert if format has suffix. Disabled by default.
-- [s3_skip_empty_files](/docs/en/operations/settings/settings.md#s3_skip_empty_files) - allows to skip empty files while reading. Disabled by default.
+- [s3_skip_empty_files](/docs/en/operations/settings/settings.md#s3_skip_empty_files) - allows to skip empty files while reading. Enabled by default.
 
 **See Also**
 

docs/ru/sql-reference/functions/array-functions.md

@@ -1617,16 +1617,18 @@ SELECT arrayCumSum([1, 1, 1, 1]) AS res
 └──────────────┘
 ```
 
-## arrayAUC {#arrayauc}
+## arrayRocAUC {#arrayrocauc}
 
 Вычисляет площадь под кривой.
 
 **Синтаксис**
 
 ``` sql
-arrayAUC(arr_scores, arr_labels)
+arrayRocAUC(arr_scores, arr_labels)
 ```
 
+Синоним: `arrayAUC`.
+
 **Аргументы**
 
 - `arr_scores` — оценка, которую дает модель предсказания.
@@ -1643,15 +1645,15 @@ arrayAUC(arr_scores, arr_labels)
 Запрос:
 
 ``` sql
-SELECT arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
+SELECT arrayRocAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
 ```
 
 Результат:
 
 ``` text
-┌─arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
-│                                          0.75 │
-└────────────────────────────────────────---──┘
+┌─arrayRocAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
+│                                             0.75 │
+└──────────────────────────────────────────────────┘
 ```
 
 ## arrayProduct {#arrayproduct}

docs/zh/sql-reference/functions/array-functions.md

@@ -1186,16 +1186,18 @@ SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);
 └──────────────────────────────────────┘
 ```
 
-## arrayAUC {#arrayauc}
+## arrayRocAUC {#arrayrocauc}
 
 计算AUC (ROC曲线下的面积，这是机器学习中的一个概念，更多细节请查看：https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve)。
 
 **语法**
 
 ``` sql
-arrayAUC(arr_scores, arr_labels)
+arrayRocAUC(arr_scores, arr_labels)
 ```
 
+别名: `arrayAUC`.
+
 **参数**
 
 - `arr_scores` — 分数预测模型给出。
@@ -1210,15 +1212,15 @@ arrayAUC(arr_scores, arr_labels)
 查询语句:
 
 ``` sql
-select arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
+select arrayRocAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
 ```
 
 结果:
 
 ``` text
-┌─arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
-│                                          0.75 │
-└───────────────────────────────────────────────┘
+┌─arrayRocAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
+│                                             0.75 │
+└──────────────────────────────────────────────────┘
 ```
 
 ## arrayMap(func, arr1, ...) {#array-map}

src/Access/Common/AccessRightsElement.cpp

@@ -9,6 +9,12 @@
 
 namespace DB
 {
+
+namespace ErrorCodes
+{
+    extern const int INVALID_GRANT;
+}
+
 namespace
 {
     void formatOptions(bool grant_option, bool is_partial_revoke, String & result)
@@ -211,18 +217,43 @@ AccessRightsElement::AccessRightsElement(
 {
 }
 
-void AccessRightsElement::eraseNonGrantable()
+AccessFlags AccessRightsElement::getGrantableFlags() const
 {
     if (isGlobalWithParameter() && !anyParameter())
-        access_flags &= AccessFlags::allFlagsGrantableOnGlobalWithParameterLevel();
+        return access_flags & AccessFlags::allFlagsGrantableOnGlobalWithParameterLevel();
     else if (!anyColumn())
-        access_flags &= AccessFlags::allFlagsGrantableOnColumnLevel();
+        return access_flags & AccessFlags::allFlagsGrantableOnColumnLevel();
     else if (!anyTable())
-        access_flags &= AccessFlags::allFlagsGrantableOnTableLevel();
+        return access_flags & AccessFlags::allFlagsGrantableOnTableLevel();
     else if (!anyDatabase())
-        access_flags &= AccessFlags::allFlagsGrantableOnDatabaseLevel();
+        return access_flags & AccessFlags::allFlagsGrantableOnDatabaseLevel();
     else
-        access_flags &= AccessFlags::allFlagsGrantableOnGlobalLevel();
+        return access_flags & AccessFlags::allFlagsGrantableOnGlobalLevel();
+}
+
+void AccessRightsElement::throwIfNotGrantable() const
+{
+    if (empty())
+        return;
+    auto grantable_flags = getGrantableFlags();
+    if (grantable_flags)
+        return;
+
+    if (!anyColumn())
+        throw Exception(ErrorCodes::INVALID_GRANT, "{} cannot be granted on the column level", access_flags.toString());
+    if (!anyTable())
+        throw Exception(ErrorCodes::INVALID_GRANT, "{} cannot be granted on the table level", access_flags.toString());
+    if (!anyDatabase())
+        throw Exception(ErrorCodes::INVALID_GRANT, "{} cannot be granted on the database level", access_flags.toString());
+    if (!anyParameter())
+        throw Exception(ErrorCodes::INVALID_GRANT, "{} cannot be granted on the global with parameter level", access_flags.toString());
+
+    throw Exception(ErrorCodes::INVALID_GRANT, "{} cannot be granted", access_flags.toString());
+}
+
+void AccessRightsElement::eraseNotGrantable()
+{
+    access_flags = getGrantableFlags();
 }
 
 void AccessRightsElement::replaceEmptyDatabase(const String & current_database)
@@ -251,11 +282,17 @@ bool AccessRightsElements::sameOptions() const
     return (size() < 2) || std::all_of(std::next(begin()), end(), [this](const AccessRightsElement & e) { return e.sameOptions(front()); });
 }
 
-void AccessRightsElements::eraseNonGrantable()
+void AccessRightsElements::throwIfNotGrantable() const
+{
+    for (const auto & element : *this)
+        element.throwIfNotGrantable();
+}
+
+void AccessRightsElements::eraseNotGrantable()
 {
     std::erase_if(*this, [](AccessRightsElement & element)
     {
-        element.eraseNonGrantable();
+        element.eraseNotGrantable();
         return element.empty();
     });
 }
@@ -269,4 +306,45 @@ void AccessRightsElements::replaceEmptyDatabase(const String & current_database)
 String AccessRightsElements::toString() const { return toStringImpl(*this, true); }
 String AccessRightsElements::toStringWithoutOptions() const { return toStringImpl(*this, false); }
 
+void AccessRightsElements::formatElementsWithoutOptions(WriteBuffer & buffer, bool hilite) const
+{
+    bool no_output = true;
+    for (size_t i = 0; i != size(); ++i)
+    {
+        const auto & element = (*this)[i];
+        auto keywords = element.access_flags.toKeywords();
+        if (keywords.empty() || (!element.anyColumn() && element.columns.empty()))
+            continue;
+
+        for (const auto & keyword : keywords)
+        {
+            if (!std::exchange(no_output, false))
+                buffer << ", ";
+
+            buffer << (hilite ? IAST::hilite_keyword : "") << keyword << (hilite ? IAST::hilite_none : "");
+            if (!element.anyColumn())
+                element.formatColumnNames(buffer);
+        }
+
+        bool next_element_on_same_db_and_table = false;
+        if (i != size() - 1)
+        {
+            const auto & next_element = (*this)[i + 1];
+            if (element.sameDatabaseAndTableAndParameter(next_element))
+            {
+                next_element_on_same_db_and_table = true;
+            }
+        }
+
+        if (!next_element_on_same_db_and_table)
+        {
+            buffer << " ";
+            element.formatONClause(buffer, hilite);
+        }
+    }
+
+    if (no_output)
+        buffer << (hilite ? IAST::hilite_keyword : "") << "USAGE ON " << (hilite ? IAST::hilite_none : "") << "*.*";
+}
+
 }

src/Access/Common/AccessRightsElement.h

@@ -79,8 +79,14 @@ struct AccessRightsElement
         return (grant_option == other.grant_option) && (is_partial_revoke == other.is_partial_revoke);
     }
 
+    /// Returns only those flags which can be granted.
+    AccessFlags getGrantableFlags() const;
+
+    /// Throws an exception if some flags can't be granted.
+    void throwIfNotGrantable() const;
+
     /// Resets flags which cannot be granted.
-    void eraseNonGrantable();
+    void eraseNotGrantable();
 
     bool isEmptyDatabase() const { return database.empty() and !anyDatabase(); }
 
@@ -110,8 +116,11 @@ public:
     bool sameDatabaseAndTable() const;
     bool sameOptions() const;
 
+    /// Throws an exception if some flags can't be granted.
+    void throwIfNotGrantable() const;
+
     /// Resets flags which cannot be granted.
-    void eraseNonGrantable();
+    void eraseNotGrantable();
 
     /// If the database is empty, replaces it with `current_database`. Otherwise does nothing.
     void replaceEmptyDatabase(const String & current_database);
@@ -119,6 +128,7 @@ public:
     /// Returns a human-readable representation like "GRANT SELECT, UPDATE(x, y) ON db.table".
     String toString() const;
     String toStringWithoutOptions() const;
+    void formatElementsWithoutOptions(WriteBuffer & buffer, bool hilite) const;
 };
 
 }

src/Analyzer/Passes/GroupingFunctionsResolvePass.cpp

@@ -4,6 +4,7 @@
 #include <Core/Settings.h>
 
 #include <Functions/grouping.h>
+#include <Functions/IFunctionAdaptors.h>
 
 #include <Interpreters/Context.h>
 

src/Analyzer/Resolve/QueryAnalyzer.cpp

@@ -13,6 +13,7 @@
 #include <DataTypes/getLeastSupertype.h>
 
 #include <Functions/FunctionFactory.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <Functions/UserDefined/UserDefinedExecutableFunctionFactory.h>
 #include <Functions/UserDefined/UserDefinedSQLFunctionFactory.h>
 #include <Functions/grouping.h>

src/CMakeLists.txt

@@ -639,6 +639,10 @@ if (TARGET ch_rust::skim)
     dbms_target_link_libraries(PUBLIC ch_rust::skim)
 endif()
 
+if (TARGET ch_contrib::google_cloud_cpp)
+    dbms_target_link_libraries(PUBLIC ch_contrib::google_cloud_cpp)
+endif()
+
 if (ENABLE_TESTS)
     macro (grep_gtest_sources BASE_DIR DST_VAR)
         # Cold match files that are not in tests/ directories

src/Columns/ColumnDecimal.cpp

@@ -8,6 +8,10 @@
 #include <Common/assert_cast.h>
 #include <Common/iota.h>
 
+#include <Core/DecimalFunctions.h>
+#include <Core/TypeId.h>
+
+#include <base/TypeName.h>
 #include <base/sort.h>
 
 #include <IO/WriteHelpers.h>
@@ -30,6 +34,19 @@ namespace ErrorCodes
     extern const int NOT_IMPLEMENTED;
 }
 
+template <is_decimal T>
+const char * ColumnDecimal<T>::getFamilyName() const
+{
+    return TypeName<T>.data();
+}
+
+template <is_decimal T>
+TypeIndex ColumnDecimal<T>::getDataType() const
+{
+    return TypeToTypeIndex<T>;
+}
+
+
 template <is_decimal T>
 #if !defined(DEBUG_OR_SANITIZER_BUILD)
 int ColumnDecimal<T>::compareAt(size_t n, size_t m, const IColumn & rhs_, int) const
@@ -46,6 +63,12 @@ int ColumnDecimal<T>::doCompareAt(size_t n, size_t m, const IColumn & rhs_, int)
     return decimalLess<T>(b, a, other.scale, scale) ? 1 : (decimalLess<T>(a, b, scale, other.scale) ? -1 : 0);
 }
 
+template <is_decimal T>
+Float64 ColumnDecimal<T>::getFloat64(size_t n) const
+{
+    return DecimalUtils::convertTo<Float64>(data[n], scale);
+}
+
 template <is_decimal T>
 const char * ColumnDecimal<T>::deserializeAndInsertFromArena(const char * pos)
 {

src/Columns/ColumnDecimal.h

@@ -1,14 +1,9 @@
 #pragma once
 
-#include <base/sort.h>
-#include <base/TypeName.h>
-#include <Core/Field.h>
-#include <Core/DecimalFunctions.h>
-#include <Core/TypeId.h>
-#include <Common/typeid_cast.h>
 #include <Columns/ColumnFixedSizeHelper.h>
 #include <Columns/IColumn.h>
 #include <Columns/IColumnImpl.h>
+#include <Core/Field.h>
 
 
 namespace DB
@@ -39,8 +34,8 @@ private:
     {}
 
 public:
-    const char * getFamilyName() const override { return TypeName<T>.data(); }
-    TypeIndex getDataType() const override { return TypeToTypeIndex<T>; }
+    const char * getFamilyName() const override;
+    TypeIndex getDataType() const override;
 
     bool isNumeric() const override { return false; }
     bool canBeInsideNullable() const override { return true; }
@@ -98,7 +93,7 @@ public:
         return StringRef(reinterpret_cast<const char *>(&data[n]), sizeof(data[n]));
     }
 
-    Float64 getFloat64(size_t n) const final { return DecimalUtils::convertTo<Float64>(data[n], scale); }
+    Float64 getFloat64(size_t n) const final;
 
     const char * deserializeAndInsertFromArena(const char * pos) override;
     const char * skipSerializedInArena(const char * pos) const override;

src/Columns/ColumnFunction.cpp

@@ -347,7 +347,7 @@ ColumnWithTypeAndName ColumnFunction::reduce() const
     if (is_function_compiled)
         ProfileEvents::increment(ProfileEvents::CompiledFunctionExecute);
 
-    res.column = function->execute(columns, res.type, elements_size);
+    res.column = function->execute(columns, res.type, elements_size, /* dry_run = */ false);
     if (res.column->getDataType() != res.type->getColumnType())
         throw Exception(
             ErrorCodes::LOGICAL_ERROR,

src/Columns/ColumnVector.cpp

@@ -32,6 +32,8 @@
 #    include <emmintrin.h>
 #endif
 
+#include "config.h"
+
 #if USE_MULTITARGET_CODE
 #    include <immintrin.h>
 #endif
@@ -658,7 +660,7 @@ inline void doFilterAligned(const UInt8 *& filt_pos, const UInt8 *& filt_end_ali
                             reinterpret_cast<void *>(&res_data[current_offset]), mask & KMASK);
                     current_offset += std::popcount(mask & KMASK);
                     /// prepare mask for next iter, if ELEMENTS_PER_VEC = 64, no next iter
-                    if (ELEMENTS_PER_VEC < 64)
+                    if constexpr (ELEMENTS_PER_VEC < 64)
                     {
                         mask >>= ELEMENTS_PER_VEC;
                     }
@@ -992,6 +994,151 @@ ColumnPtr ColumnVector<T>::createWithOffsets(const IColumn::Offsets & offsets, c
     return res;
 }
 
+DECLARE_DEFAULT_CODE(
+    template <typename Container, typename Type> void vectorIndexImpl(
+    const Container & data, const PaddedPODArray<Type> & indexes, size_t limit, Container & res_data)
+    {
+        for (size_t i = 0; i < limit; ++i)
+            res_data[i] = data[indexes[i]];
+    }
+);
+
+DECLARE_AVX512VBMI_SPECIFIC_CODE(
+    template <typename Container, typename Type>
+    void vectorIndexImpl(const Container & data, const PaddedPODArray<Type> & indexes, size_t limit, Container & res_data)
+    {
+        static constexpr UInt64 MASK64 = 0xffffffffffffffff;
+        const size_t limit64 = limit & ~63;
+        size_t pos = 0;
+        size_t data_size = data.size();
+
+        auto data_pos = reinterpret_cast<const UInt8 *>(data.data());
+        auto indexes_pos = reinterpret_cast<const UInt8 *>(indexes.data());
+        auto res_pos = reinterpret_cast<UInt8 *>(res_data.data());
+
+        if (limit == 0)
+            return; /// nothing to do, just return
+
+        if (data_size <= 64)
+        {
+            /// one single mask load for table size <= 64
+            __mmask64 last_mask = MASK64 >> (64 - data_size);
+            __m512i table1 = _mm512_maskz_loadu_epi8(last_mask, data_pos);
+
+            /// 64 bytes table lookup using one single permutexvar_epi8
+            while (pos < limit64)
+            {
+                __m512i vidx = _mm512_loadu_epi8(indexes_pos + pos);
+                __m512i out = _mm512_permutexvar_epi8(vidx, table1);
+                _mm512_storeu_epi8(res_pos + pos, out);
+                pos += 64;
+            }
+            /// tail handling
+            if (limit > limit64)
+            {
+                __mmask64 tail_mask = MASK64 >> (limit64 + 64 - limit);
+                __m512i vidx = _mm512_maskz_loadu_epi8(tail_mask, indexes_pos + pos);
+                __m512i out = _mm512_permutexvar_epi8(vidx, table1);
+                _mm512_mask_storeu_epi8(res_pos + pos, tail_mask, out);
+            }
+        }
+        else if (data_size <= 128)
+        {
+            /// table size (64, 128] requires 2 zmm load
+            __mmask64 last_mask = MASK64 >> (128 - data_size);
+            __m512i table1 = _mm512_loadu_epi8(data_pos);
+            __m512i table2 = _mm512_maskz_loadu_epi8(last_mask, data_pos + 64);
+
+            /// 128 bytes table lookup using one single permute2xvar_epi8
+            while (pos < limit64)
+            {
+                __m512i vidx = _mm512_loadu_epi8(indexes_pos + pos);
+                __m512i out = _mm512_permutex2var_epi8(table1, vidx, table2);
+                _mm512_storeu_epi8(res_pos + pos, out);
+                pos += 64;
+            }
+            if (limit > limit64)
+            {
+                __mmask64 tail_mask = MASK64 >> (limit64 + 64 - limit);
+                __m512i vidx = _mm512_maskz_loadu_epi8(tail_mask, indexes_pos + pos);
+                __m512i out = _mm512_permutex2var_epi8(table1, vidx, table2);
+                _mm512_mask_storeu_epi8(res_pos + pos, tail_mask, out);
+            }
+        }
+        else
+        {
+            if (data_size > 256)
+            {
+                /// byte index will not exceed 256 boundary.
+                data_size = 256;
+            }
+
+            __m512i table1 = _mm512_loadu_epi8(data_pos);
+            __m512i table2 = _mm512_loadu_epi8(data_pos + 64);
+            __m512i table3, table4;
+            if (data_size <= 192)
+            {
+                /// only 3 tables need to load if size <= 192
+                __mmask64 last_mask = MASK64 >> (192 - data_size);
+                table3 = _mm512_maskz_loadu_epi8(last_mask, data_pos + 128);
+                table4 = _mm512_setzero_si512();
+            }
+            else
+            {
+                __mmask64 last_mask = MASK64 >> (256 - data_size);
+                table3 = _mm512_loadu_epi8(data_pos + 128);
+                table4 = _mm512_maskz_loadu_epi8(last_mask, data_pos + 192);
+            }
+
+            /// 256 bytes table lookup can use: 2 permute2xvar_epi8 plus 1 blender with MSB
+            while (pos < limit64)
+            {
+                __m512i vidx = _mm512_loadu_epi8(indexes_pos + pos);
+                __m512i tmp1 = _mm512_permutex2var_epi8(table1, vidx, table2);
+                __m512i tmp2 = _mm512_permutex2var_epi8(table3, vidx, table4);
+                __mmask64 msb = _mm512_movepi8_mask(vidx);
+                __m512i out = _mm512_mask_blend_epi8(msb, tmp1, tmp2);
+                _mm512_storeu_epi8(res_pos + pos, out);
+                pos += 64;
+            }
+            if (limit > limit64)
+            {
+                __mmask64 tail_mask = MASK64 >> (limit64 + 64 - limit);
+                __m512i vidx = _mm512_maskz_loadu_epi8(tail_mask, indexes_pos + pos);
+                __m512i tmp1 = _mm512_permutex2var_epi8(table1, vidx, table2);
+                __m512i tmp2 = _mm512_permutex2var_epi8(table3, vidx, table4);
+                __mmask64 msb = _mm512_movepi8_mask(vidx);
+                __m512i out = _mm512_mask_blend_epi8(msb, tmp1, tmp2);
+                _mm512_mask_storeu_epi8(res_pos + pos, tail_mask, out);
+            }
+        }
+    }
+);
+
+template <typename T>
+template <typename Type>
+ColumnPtr ColumnVector<T>::indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const
+{
+    chassert(limit <= indexes.size());
+
+    auto res = this->create(limit);
+    typename Self::Container & res_data = res->getData();
+#if USE_MULTITARGET_CODE
+    if constexpr (sizeof(T) == 1 && sizeof(Type) == 1)
+    {
+        /// VBMI optimization only applicable for (U)Int8 types
+        if (isArchSupported(TargetArch::AVX512VBMI))
+        {
+            TargetSpecific::AVX512VBMI::vectorIndexImpl<Container, Type>(data, indexes, limit, res_data);
+            return res;
+        }
+    }
+#endif
+    TargetSpecific::Default::vectorIndexImpl<Container, Type>(data, indexes, limit, res_data);
+
+    return res;
+}
+
 /// Explicit template instantiations - to avoid code bloat in headers.
 template class ColumnVector<UInt8>;
 template class ColumnVector<UInt16>;
@@ -1012,4 +1159,17 @@ template class ColumnVector<UUID>;
 template class ColumnVector<IPv4>;
 template class ColumnVector<IPv6>;
 
+INSTANTIATE_INDEX_TEMPLATE_IMPL(ColumnVector)
+/// Used by ColumnVariant.cpp
+template ColumnPtr ColumnVector<UInt8>::indexImpl<UInt16>(const PaddedPODArray<UInt16> & indexes, size_t limit) const;
+template ColumnPtr ColumnVector<UInt8>::indexImpl<UInt32>(const PaddedPODArray<UInt32> & indexes, size_t limit) const;
+template ColumnPtr ColumnVector<UInt8>::indexImpl<UInt64>(const PaddedPODArray<UInt64> & indexes, size_t limit) const;
+template ColumnPtr ColumnVector<UInt64>::indexImpl<UInt8>(const PaddedPODArray<UInt8> & indexes, size_t limit) const;
+template ColumnPtr ColumnVector<UInt64>::indexImpl<UInt16>(const PaddedPODArray<UInt16> & indexes, size_t limit) const;
+template ColumnPtr ColumnVector<UInt64>::indexImpl<UInt32>(const PaddedPODArray<UInt32> & indexes, size_t limit) const;
+
+#if defined(OS_DARWIN)
+template ColumnPtr ColumnVector<UInt8>::indexImpl<size_t>(const PaddedPODArray<size_t> & indexes, size_t limit) const;
+template ColumnPtr ColumnVector<UInt64>::indexImpl<size_t>(const PaddedPODArray<size_t> & indexes, size_t limit) const;
+#endif
 }

src/Columns/ColumnVector.h

@@ -13,10 +13,6 @@
 
 #include "config.h"
 
-#if USE_MULTITARGET_CODE
-#    include <immintrin.h>
-#endif
-
 namespace DB
 {
 
@@ -320,151 +316,6 @@ protected:
     Container data;
 };
 
-DECLARE_DEFAULT_CODE(
-template <typename Container, typename Type>
-inline void vectorIndexImpl(const Container & data, const PaddedPODArray<Type> & indexes, size_t limit, Container & res_data)
-{
-    for (size_t i = 0; i < limit; ++i)
-        res_data[i] = data[indexes[i]];
-}
-);
-
-DECLARE_AVX512VBMI_SPECIFIC_CODE(
-template <typename Container, typename Type>
-inline void vectorIndexImpl(const Container & data, const PaddedPODArray<Type> & indexes, size_t limit, Container & res_data)
-{
-    static constexpr UInt64 MASK64 = 0xffffffffffffffff;
-    const size_t limit64 = limit & ~63;
-    size_t pos = 0;
-    size_t data_size = data.size();
-
-    auto data_pos = reinterpret_cast<const UInt8 *>(data.data());
-    auto indexes_pos = reinterpret_cast<const UInt8 *>(indexes.data());
-    auto res_pos = reinterpret_cast<UInt8 *>(res_data.data());
-
-    if (limit == 0)
-        return;   /// nothing to do, just return
-
-    if (data_size <= 64)
-    {
-        /// one single mask load for table size <= 64
-        __mmask64 last_mask = MASK64 >> (64 - data_size);
-        __m512i table1 = _mm512_maskz_loadu_epi8(last_mask, data_pos);
-
-        /// 64 bytes table lookup using one single permutexvar_epi8
-        while (pos < limit64)
-        {
-            __m512i vidx = _mm512_loadu_epi8(indexes_pos + pos);
-            __m512i out = _mm512_permutexvar_epi8(vidx, table1);
-            _mm512_storeu_epi8(res_pos + pos, out);
-            pos += 64;
-        }
-        /// tail handling
-        if (limit > limit64)
-        {
-            __mmask64 tail_mask = MASK64 >> (limit64 + 64 - limit);
-            __m512i vidx = _mm512_maskz_loadu_epi8(tail_mask, indexes_pos + pos);
-            __m512i out = _mm512_permutexvar_epi8(vidx, table1);
-            _mm512_mask_storeu_epi8(res_pos + pos, tail_mask, out);
-        }
-    }
-    else if (data_size <= 128)
-    {
-        /// table size (64, 128] requires 2 zmm load
-        __mmask64 last_mask = MASK64 >> (128 - data_size);
-        __m512i table1 = _mm512_loadu_epi8(data_pos);
-        __m512i table2 = _mm512_maskz_loadu_epi8(last_mask, data_pos + 64);
-
-        /// 128 bytes table lookup using one single permute2xvar_epi8
-        while (pos < limit64)
-        {
-            __m512i vidx = _mm512_loadu_epi8(indexes_pos + pos);
-            __m512i out = _mm512_permutex2var_epi8(table1, vidx, table2);
-            _mm512_storeu_epi8(res_pos + pos, out);
-            pos += 64;
-        }
-        if (limit > limit64)
-        {
-            __mmask64 tail_mask = MASK64 >> (limit64 + 64 - limit);
-            __m512i vidx = _mm512_maskz_loadu_epi8(tail_mask, indexes_pos + pos);
-            __m512i out = _mm512_permutex2var_epi8(table1, vidx, table2);
-            _mm512_mask_storeu_epi8(res_pos + pos, tail_mask, out);
-        }
-    }
-    else
-    {
-        if (data_size > 256)
-        {
-            /// byte index will not exceed 256 boundary.
-            data_size = 256;
-        }
-
-        __m512i table1 = _mm512_loadu_epi8(data_pos);
-        __m512i table2 = _mm512_loadu_epi8(data_pos + 64);
-        __m512i table3, table4;
-        if (data_size <= 192)
-        {
-            /// only 3 tables need to load if size <= 192
-            __mmask64 last_mask = MASK64 >> (192 - data_size);
-            table3 = _mm512_maskz_loadu_epi8(last_mask, data_pos + 128);
-            table4 = _mm512_setzero_si512();
-        }
-        else
-        {
-            __mmask64 last_mask = MASK64 >> (256 - data_size);
-            table3 = _mm512_loadu_epi8(data_pos + 128);
-            table4 = _mm512_maskz_loadu_epi8(last_mask, data_pos + 192);
-        }
-
-        /// 256 bytes table lookup can use: 2 permute2xvar_epi8 plus 1 blender with MSB
-        while (pos < limit64)
-        {
-            __m512i vidx = _mm512_loadu_epi8(indexes_pos + pos);
-            __m512i tmp1 = _mm512_permutex2var_epi8(table1, vidx, table2);
-            __m512i tmp2 = _mm512_permutex2var_epi8(table3, vidx, table4);
-            __mmask64 msb = _mm512_movepi8_mask(vidx);
-            __m512i out = _mm512_mask_blend_epi8(msb, tmp1, tmp2);
-            _mm512_storeu_epi8(res_pos + pos, out);
-            pos += 64;
-        }
-        if (limit > limit64)
-        {
-            __mmask64 tail_mask = MASK64 >> (limit64 + 64 - limit);
-            __m512i vidx = _mm512_maskz_loadu_epi8(tail_mask, indexes_pos + pos);
-            __m512i tmp1 = _mm512_permutex2var_epi8(table1, vidx, table2);
-            __m512i tmp2 = _mm512_permutex2var_epi8(table3, vidx, table4);
-            __mmask64 msb = _mm512_movepi8_mask(vidx);
-            __m512i out = _mm512_mask_blend_epi8(msb, tmp1, tmp2);
-            _mm512_mask_storeu_epi8(res_pos + pos, tail_mask, out);
-        }
-    }
-}
-);
-
-template <typename T>
-template <typename Type>
-ColumnPtr ColumnVector<T>::indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const
-{
-    assert(limit <= indexes.size());
-
-    auto res = this->create(limit);
-    typename Self::Container & res_data = res->getData();
-#if USE_MULTITARGET_CODE
-    if constexpr (sizeof(T) == 1 && sizeof(Type) == 1)
-    {
-        /// VBMI optimization only applicable for (U)Int8 types
-        if (isArchSupported(TargetArch::AVX512VBMI))
-        {
-            TargetSpecific::AVX512VBMI::vectorIndexImpl<Container, Type>(data, indexes, limit, res_data);
-            return res;
-        }
-    }
-#endif
-    TargetSpecific::Default::vectorIndexImpl<Container, Type>(data, indexes, limit, res_data);
-
-    return res;
-}
-
 template <class TCol>
 concept is_col_vector = std::is_same_v<TCol, ColumnVector<typename TCol::ValueType>>;
 

src/Columns/ColumnsCommon.h

@@ -142,4 +142,10 @@ ColumnPtr permuteImpl(const Column & column, const IColumn::Permutation & perm,
     template ColumnPtr Column::indexImpl<UInt16>(const PaddedPODArray<UInt16> & indexes, size_t limit) const; \
     template ColumnPtr Column::indexImpl<UInt32>(const PaddedPODArray<UInt32> & indexes, size_t limit) const; \
     template ColumnPtr Column::indexImpl<UInt64>(const PaddedPODArray<UInt64> & indexes, size_t limit) const;
+
+#define INSTANTIATE_INDEX_TEMPLATE_IMPL(ColumnTemplate) \
+    template ColumnPtr ColumnTemplate<UInt8>::indexImpl<UInt8>(const PaddedPODArray<UInt8> & indexes, size_t limit) const; \
+    template ColumnPtr ColumnTemplate<UInt16>::indexImpl<UInt16>(const PaddedPODArray<UInt16> & indexes, size_t limit) const; \
+    template ColumnPtr ColumnTemplate<UInt32>::indexImpl<UInt32>(const PaddedPODArray<UInt32> & indexes, size_t limit) const; \
+    template ColumnPtr ColumnTemplate<UInt64>::indexImpl<UInt64>(const PaddedPODArray<UInt64> & indexes, size_t limit) const;
 }

src/Core/DecimalComparison.h

@@ -2,6 +2,7 @@
 
 #include <base/arithmeticOverflow.h>
 #include <Core/Block.h>
+#include <Core/DecimalFunctions.h>
 #include <Core/AccurateComparison.h>
 #include <Core/callOnTypeIndex.h>
 #include <DataTypes/DataTypesNumber.h>
@@ -52,8 +53,8 @@ struct DecCompareInt
     using TypeB = Type;
 };
 
-template <typename A, typename B, template <typename, typename> typename Operation, bool _check_overflow = true,
-    bool _actual = is_decimal<A> || is_decimal<B>>
+template <typename A, typename B, template <typename, typename> typename Operation>
+requires is_decimal<A> || is_decimal<B>
 class DecimalComparison
 {
 public:
@@ -65,20 +66,17 @@ public:
     using ArrayA = typename ColVecA::Container;
     using ArrayB = typename ColVecB::Container;
 
-    static ColumnPtr apply(const ColumnWithTypeAndName & col_left, const ColumnWithTypeAndName & col_right)
+    static ColumnPtr apply(const ColumnWithTypeAndName & col_left, const ColumnWithTypeAndName & col_right, bool check_overflow)
     {
-        if constexpr (_actual)
-        {
-            ColumnPtr c_res;
-            Shift shift = getScales<A, B>(col_left.type, col_right.type);
+        ColumnPtr c_res;
+        Shift shift = getScales<A, B>(col_left.type, col_right.type);
 
-            return applyWithScale(col_left.column, col_right.column, shift);
-        }
-        else
-            return nullptr;
+        if (check_overflow)
+            return applyWithScale<true>(col_left.column, col_right.column, shift);
+        return applyWithScale<false>(col_left.column, col_right.column, shift);
     }
 
-    static bool compare(A a, B b, UInt32 scale_a, UInt32 scale_b)
+    static bool compare(A a, B b, UInt32 scale_a, UInt32 scale_b, bool check_overflow)
     {
         static const UInt32 max_scale = DecimalUtils::max_precision<Decimal256>;
         if (scale_a > max_scale || scale_b > max_scale)
@@ -90,7 +88,9 @@ public:
         if (scale_a > scale_b)
             shift.b = static_cast<CompareInt>(DecimalUtils::scaleMultiplier<A>(scale_a - scale_b));
 
-        return applyWithScale(a, b, shift);
+        if (check_overflow)
+            return applyWithScale<true>(a, b, shift);
+        return applyWithScale<false>(a, b, shift);
     }
 
 private:
@@ -104,14 +104,14 @@ private:
         bool right() const { return b != 1; }
     };
 
-    template <typename T, typename U>
+    template <bool check_overflow, typename T, typename U>
     static auto applyWithScale(T a, U b, const Shift & shift)
     {
         if (shift.left())
-            return apply<true, false>(a, b, shift.a);
+            return apply<check_overflow, true, false>(a, b, shift.a);
         if (shift.right())
-            return apply<false, true>(a, b, shift.b);
-        return apply<false, false>(a, b, 1);
+            return apply<check_overflow, false, true>(a, b, shift.b);
+        return apply<check_overflow, false, false>(a, b, 1);
     }
 
     template <typename T, typename U>
@@ -125,8 +125,8 @@ private:
         if (decimal0 && decimal1)
         {
             auto result_type = DecimalUtils::binaryOpResult<false, false>(*decimal0, *decimal1);
-            shift.a = static_cast<CompareInt>(result_type.scaleFactorFor(decimal0->getTrait(), false).value);
-            shift.b = static_cast<CompareInt>(result_type.scaleFactorFor(decimal1->getTrait(), false).value);
+            shift.a = static_cast<CompareInt>(result_type.scaleFactorFor(DecimalUtils::DataTypeDecimalTrait<T>{decimal0->getPrecision(), decimal0->getScale()}, false).value);
+            shift.b = static_cast<CompareInt>(result_type.scaleFactorFor(DecimalUtils::DataTypeDecimalTrait<U>{decimal1->getPrecision(), decimal1->getScale()}, false).value);
         }
         else if (decimal0)
             shift.b = static_cast<CompareInt>(decimal0->getScaleMultiplier().value);
@@ -158,66 +158,63 @@ private:
         return shift;
     }
 
-    template <bool scale_left, bool scale_right>
+    template <bool check_overflow, bool scale_left, bool scale_right>
     static ColumnPtr apply(const ColumnPtr & c0, const ColumnPtr & c1, CompareInt scale)
     {
         auto c_res = ColumnUInt8::create();
 
-        if constexpr (_actual)
+        bool c0_is_const = isColumnConst(*c0);
+        bool c1_is_const = isColumnConst(*c1);
+
+        if (c0_is_const && c1_is_const)
         {
-            bool c0_is_const = isColumnConst(*c0);
-            bool c1_is_const = isColumnConst(*c1);
+            const ColumnConst & c0_const = checkAndGetColumnConst<ColVecA>(*c0);
+            const ColumnConst & c1_const = checkAndGetColumnConst<ColVecB>(*c1);
 
-            if (c0_is_const && c1_is_const)
+            A a = c0_const.template getValue<A>();
+            B b = c1_const.template getValue<B>();
+            UInt8 res = apply<check_overflow, scale_left, scale_right>(a, b, scale);
+            return DataTypeUInt8().createColumnConst(c0->size(), toField(res));
+        }
+
+        ColumnUInt8::Container & vec_res = c_res->getData();
+        vec_res.resize(c0->size());
+
+        if (c0_is_const)
+        {
+            const ColumnConst & c0_const = checkAndGetColumnConst<ColVecA>(*c0);
+            A a = c0_const.template getValue<A>();
+            if (const ColVecB * c1_vec = checkAndGetColumn<ColVecB>(c1.get()))
+                constantVector<check_overflow, scale_left, scale_right>(a, c1_vec->getData(), vec_res, scale);
+            else
+                throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong column in Decimal comparison");
+        }
+        else if (c1_is_const)
+        {
+            const ColumnConst & c1_const = checkAndGetColumnConst<ColVecB>(*c1);
+            B b = c1_const.template getValue<B>();
+            if (const ColVecA * c0_vec = checkAndGetColumn<ColVecA>(c0.get()))
+                vectorConstant<check_overflow, scale_left, scale_right>(c0_vec->getData(), b, vec_res, scale);
+            else
+                throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong column in Decimal comparison");
+        }
+        else
+        {
+            if (const ColVecA * c0_vec = checkAndGetColumn<ColVecA>(c0.get()))
             {
-                const ColumnConst & c0_const = checkAndGetColumnConst<ColVecA>(*c0);
-                const ColumnConst & c1_const = checkAndGetColumnConst<ColVecB>(*c1);
-
-                A a = c0_const.template getValue<A>();
-                B b = c1_const.template getValue<B>();
-                UInt8 res = apply<scale_left, scale_right>(a, b, scale);
-                return DataTypeUInt8().createColumnConst(c0->size(), toField(res));
-            }
-
-            ColumnUInt8::Container & vec_res = c_res->getData();
-            vec_res.resize(c0->size());
-
-            if (c0_is_const)
-            {
-                const ColumnConst & c0_const = checkAndGetColumnConst<ColVecA>(*c0);
-                A a = c0_const.template getValue<A>();
                 if (const ColVecB * c1_vec = checkAndGetColumn<ColVecB>(c1.get()))
-                    constantVector<scale_left, scale_right>(a, c1_vec->getData(), vec_res, scale);
-                else
-                    throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong column in Decimal comparison");
-            }
-            else if (c1_is_const)
-            {
-                const ColumnConst & c1_const = checkAndGetColumnConst<ColVecB>(*c1);
-                B b = c1_const.template getValue<B>();
-                if (const ColVecA * c0_vec = checkAndGetColumn<ColVecA>(c0.get()))
-                    vectorConstant<scale_left, scale_right>(c0_vec->getData(), b, vec_res, scale);
+                    vectorVector<check_overflow, scale_left, scale_right>(c0_vec->getData(), c1_vec->getData(), vec_res, scale);
                 else
                     throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong column in Decimal comparison");
             }
             else
-            {
-                if (const ColVecA * c0_vec = checkAndGetColumn<ColVecA>(c0.get()))
-                {
-                    if (const ColVecB * c1_vec = checkAndGetColumn<ColVecB>(c1.get()))
-                        vectorVector<scale_left, scale_right>(c0_vec->getData(), c1_vec->getData(), vec_res, scale);
-                    else
-                        throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong column in Decimal comparison");
-                }
-                else
-                    throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong column in Decimal comparison");
-            }
+                throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong column in Decimal comparison");
         }
 
         return c_res;
     }
 
-    template <bool scale_left, bool scale_right>
+    template <bool check_overflow, bool scale_left, bool scale_right>
     static NO_INLINE UInt8 apply(A a, B b, CompareInt scale [[maybe_unused]])
     {
         CompareInt x;
@@ -232,7 +229,7 @@ private:
         else
             y = static_cast<CompareInt>(b);
 
-        if constexpr (_check_overflow)
+        if constexpr (check_overflow)
         {
             bool overflow = false;
 
@@ -264,9 +261,8 @@ private:
         return Op::apply(x, y);
     }
 
-    template <bool scale_left, bool scale_right>
-    static void NO_INLINE vectorVector(const ArrayA & a, const ArrayB & b, PaddedPODArray<UInt8> & c,
-                                        CompareInt scale)
+    template <bool check_overflow, bool scale_left, bool scale_right>
+    static void NO_INLINE vectorVector(const ArrayA & a, const ArrayB & b, PaddedPODArray<UInt8> & c, CompareInt scale)
     {
         size_t size = a.size();
         const A * a_pos = a.data();
@@ -276,14 +272,14 @@ private:
 
         while (a_pos < a_end)
         {
-            *c_pos = apply<scale_left, scale_right>(*a_pos, *b_pos, scale);
+            *c_pos = apply<check_overflow, scale_left, scale_right>(*a_pos, *b_pos, scale);
             ++a_pos;
             ++b_pos;
             ++c_pos;
         }
     }
 
-    template <bool scale_left, bool scale_right>
+    template <bool check_overflow, bool scale_left, bool scale_right>
     static void NO_INLINE vectorConstant(const ArrayA & a, B b, PaddedPODArray<UInt8> & c, CompareInt scale)
     {
         size_t size = a.size();
@@ -293,13 +289,13 @@ private:
 
         while (a_pos < a_end)
         {
-            *c_pos = apply<scale_left, scale_right>(*a_pos, b, scale);
+            *c_pos = apply<check_overflow, scale_left, scale_right>(*a_pos, b, scale);
             ++a_pos;
             ++c_pos;
         }
     }
 
-    template <bool scale_left, bool scale_right>
+    template <bool check_overflow, bool scale_left, bool scale_right>
     static void NO_INLINE constantVector(A a, const ArrayB & b, PaddedPODArray<UInt8> & c, CompareInt scale)
     {
         size_t size = b.size();
@@ -309,7 +305,7 @@ private:
 
         while (b_pos < b_end)
         {
-            *c_pos = apply<scale_left, scale_right>(a, *b_pos, scale);
+            *c_pos = apply<check_overflow, scale_left, scale_right>(a, *b_pos, scale);
             ++b_pos;
             ++c_pos;
         }

src/Core/Field.cpp

@@ -529,22 +529,25 @@ Field Field::restoreFromDump(std::string_view dump_)
 template <typename T>
 bool decimalEqual(T x, T y, UInt32 x_scale, UInt32 y_scale)
 {
+    bool check_overflow = true;
     using Comparator = DecimalComparison<T, T, EqualsOp>;
-    return Comparator::compare(x, y, x_scale, y_scale);
+    return Comparator::compare(x, y, x_scale, y_scale, check_overflow);
 }
 
 template <typename T>
 bool decimalLess(T x, T y, UInt32 x_scale, UInt32 y_scale)
 {
+    bool check_overflow = true;
     using Comparator = DecimalComparison<T, T, LessOp>;
-    return Comparator::compare(x, y, x_scale, y_scale);
+    return Comparator::compare(x, y, x_scale, y_scale, check_overflow);
 }
 
 template <typename T>
 bool decimalLessOrEqual(T x, T y, UInt32 x_scale, UInt32 y_scale)
 {
+    bool check_overflow = true;
     using Comparator = DecimalComparison<T, T, LessOrEqualsOp>;
-    return Comparator::compare(x, y, x_scale, y_scale);
+    return Comparator::compare(x, y, x_scale, y_scale, check_overflow);
 }
 
 

src/Core/Field.h

@@ -863,6 +863,9 @@ template <> struct Field::EnumToType<Field::Types::AggregateFunctionState> { usi
 template <> struct Field::EnumToType<Field::Types::CustomType> { using Type = CustomType; };
 template <> struct Field::EnumToType<Field::Types::Bool> { using Type = UInt64; };
 
+/// Use it to prevent inclusion of magic_enum in headers, which is very expensive for the compiler
+std::string_view fieldTypeToString(Field::Types::Which type);
+
 constexpr bool isInt64OrUInt64FieldType(Field::Types::Which t)
 {
     return t == Field::Types::Int64
@@ -886,7 +889,7 @@ auto & Field::safeGet()
     if (target != which &&
         !(which == Field::Types::Bool && (target == Field::Types::UInt64 || target == Field::Types::Int64)) &&
         !(isInt64OrUInt64FieldType(which) && isInt64OrUInt64FieldType(target)))
-            throw Exception(ErrorCodes::BAD_GET, "Bad get: has {}, requested {}", getTypeName(), target);
+        throw Exception(ErrorCodes::BAD_GET, "Bad get: has {}, requested {}", getTypeName(), fieldTypeToString(target));
 
     return get<T>();
 }
@@ -1002,8 +1005,6 @@ void readQuoted(DecimalField<T> & x, ReadBuffer & buf);
 void writeFieldText(const Field & x, WriteBuffer & buf);
 
 String toString(const Field & x);
-
-std::string_view fieldTypeToString(Field::Types::Which type);
 }
 
 template <>

src/Core/Settings.cpp

@@ -433,7 +433,7 @@ Possible values:
 - 0 — `INSERT` query appends new data to the end of the file.
 - 1 — `INSERT` query creates a new file.
 )", 0) \
-    DECLARE(Bool, s3_skip_empty_files, false, R"(
+    DECLARE(Bool, s3_skip_empty_files, true, R"(
 Enables or disables skipping empty files in [S3](../../engines/table-engines/integrations/s3.md) engine tables.
 
 Possible values:

src/Core/SettingsChangesHistory.cpp

@@ -87,6 +87,7 @@ static std::initializer_list<std::pair<ClickHouseVersion, SettingsChangesHistory
             {"filesystem_cache_skip_download_if_exceeds_per_query_cache_write_limit", 1, 1, "Rename of setting skip_download_if_exceeds_query_cache_limit"},
             {"filesystem_cache_prefer_bigger_buffer_size", true, true, "New setting"},
             {"read_in_order_use_virtual_row", false, false, "Use virtual row while reading in order of primary key or its monotonic function fashion. It is useful when searching over multiple parts as only relevant ones are touched."},
+            {"s3_skip_empty_files", false, true, "We hope it will provide better UX"},
             {"filesystem_cache_boundary_alignment", 0, 0, "New setting"},
             {"push_external_roles_in_interserver_queries", false, false, "New setting."},
         }

src/Core/callOnTypeIndex.h

@@ -87,6 +87,77 @@ static bool callOnBasicType(TypeIndex number, F && f)
     return false;
 }
 
+
+template <typename T, bool _int, bool _float, bool _decimal, bool _datetime, typename F>
+static bool callOnBasicTypeSecondArg(TypeIndex number, F && f)
+{
+    if constexpr (_int)
+    {
+        switch (number)
+        {
+            case TypeIndex::UInt8:        return f(TypePair<UInt8, T>());
+            case TypeIndex::UInt16:       return f(TypePair<UInt16, T>());
+            case TypeIndex::UInt32:       return f(TypePair<UInt32, T>());
+            case TypeIndex::UInt64:       return f(TypePair<UInt64, T>());
+            case TypeIndex::UInt128:      return f(TypePair<UInt128, T>());
+            case TypeIndex::UInt256:      return f(TypePair<UInt256, T>());
+
+            case TypeIndex::Int8:         return f(TypePair<Int8, T>());
+            case TypeIndex::Int16:        return f(TypePair<Int16, T>());
+            case TypeIndex::Int32:        return f(TypePair<Int32, T>());
+            case TypeIndex::Int64:        return f(TypePair<Int64, T>());
+            case TypeIndex::Int128:       return f(TypePair<Int128, T>());
+            case TypeIndex::Int256:       return f(TypePair<Int256, T>());
+
+            case TypeIndex::Enum8:        return f(TypePair<Int8, T>());
+            case TypeIndex::Enum16:       return f(TypePair<Int16, T>());
+
+            default:
+                break;
+        }
+    }
+
+    if constexpr (_decimal)
+    {
+        switch (number)
+        {
+            case TypeIndex::Decimal32:    return f(TypePair<Decimal32, T>());
+            case TypeIndex::Decimal64:    return f(TypePair<Decimal64, T>());
+            case TypeIndex::Decimal128:   return f(TypePair<Decimal128, T>());
+            case TypeIndex::Decimal256:   return f(TypePair<Decimal256, T>());
+            default:
+                break;
+        }
+    }
+
+    if constexpr (_float)
+    {
+        switch (number)
+        {
+            case TypeIndex::BFloat16:     return f(TypePair<BFloat16, T>());
+            case TypeIndex::Float32:      return f(TypePair<Float32, T>());
+            case TypeIndex::Float64:      return f(TypePair<Float64, T>());
+            default:
+                break;
+        }
+    }
+
+    if constexpr (_datetime)
+    {
+        switch (number)
+        {
+            case TypeIndex::Date:         return f(TypePair<UInt16, T>());
+            case TypeIndex::Date32:       return f(TypePair<Int32, T>());
+            case TypeIndex::DateTime:     return f(TypePair<UInt32, T>());
+            case TypeIndex::DateTime64:   return f(TypePair<DateTime64, T>());
+            default:
+                break;
+        }
+    }
+
+    return false;
+}
+
 /// Unroll template using TypeIndex
 template <bool _int, bool _float, bool _decimal, bool _datetime, typename F>
 static inline bool callOnBasicTypes(TypeIndex type_num1, TypeIndex type_num2, F && f)

src/DataTypes/DataTypeDecimalBase.cpp

@@ -1,7 +1,8 @@
+#include <type_traits>
+#include <Core/DecimalFunctions.h>
 #include <Core/Settings.h>
 #include <DataTypes/DataTypeDecimalBase.h>
 #include <Interpreters/Context.h>
-#include <type_traits>
 
 namespace DB
 {
@@ -14,6 +15,12 @@ namespace ErrorCodes
 {
 }
 
+template <is_decimal T>
+constexpr size_t DataTypeDecimalBase<T>::maxPrecision()
+{
+    return DecimalUtils::max_precision<T>;
+}
+
 bool decimalCheckComparisonOverflow(ContextPtr context)
 {
     return context->getSettingsRef()[Setting::decimal_check_overflow];
@@ -41,6 +48,18 @@ T DataTypeDecimalBase<T>::getScaleMultiplier(UInt32 scale_)
     return DecimalUtils::scaleMultiplier<typename T::NativeType>(scale_);
 }
 
+template <is_decimal T>
+T DataTypeDecimalBase<T>::wholePart(T x) const
+{
+    return DecimalUtils::getWholePart(x, scale);
+}
+
+template <is_decimal T>
+T DataTypeDecimalBase<T>::fractionalPart(T x) const
+{
+    return DecimalUtils::getFractionalPart(x, scale);
+}
+
 
 /// Explicit template instantiations.
 template class DataTypeDecimalBase<Decimal32>;

src/DataTypes/DataTypeDecimalBase.h

@@ -3,11 +3,10 @@
 #include <cmath>
 #include <type_traits>
 
-#include <Core/TypeId.h>
-#include <Core/DecimalFunctions.h>
 #include <Columns/ColumnDecimal.h>
-#include <DataTypes/IDataType.h>
+#include <Core/TypeId.h>
 #include <DataTypes/DataTypesNumber.h>
+#include <DataTypes/IDataType.h>
 #include <Interpreters/Context_fwd.h>
 
 
@@ -64,7 +63,7 @@ public:
 
     static constexpr bool is_parametric = true;
 
-    static constexpr size_t maxPrecision() { return DecimalUtils::max_precision<T>; }
+    static constexpr size_t maxPrecision();
 
     DataTypeDecimalBase(UInt32 precision_, UInt32 scale_)
     :   precision(precision_),
@@ -104,15 +103,8 @@ public:
     UInt32 getScale() const { return scale; }
     T getScaleMultiplier() const { return getScaleMultiplier(scale); }
 
-    T wholePart(T x) const
-    {
-        return DecimalUtils::getWholePart(x, scale);
-    }
-
-    T fractionalPart(T x) const
-    {
-        return DecimalUtils::getFractionalPart(x, scale);
-    }
+    T wholePart(T x) const;
+    T fractionalPart(T x) const;
 
     T maxWholeValue() const { return getScaleMultiplier(precision - scale) - T(1); }
 
@@ -147,11 +139,6 @@ public:
 
     static T getScaleMultiplier(UInt32 scale);
 
-    DecimalUtils::DataTypeDecimalTrait<T> getTrait() const
-    {
-        return {precision, scale};
-    }
-
 protected:
     const UInt32 precision;
     const UInt32 scale;
@@ -167,50 +154,35 @@ inline const DataTypeDecimalBase<T> * checkDecimalBase(const IDataType & data_ty
     return nullptr;
 }
 
-template <bool is_multiply, bool is_division, typename T, typename U, template <typename> typename DecimalType>
-inline auto decimalResultType(const DecimalType<T> & tx, const DecimalType<U> & ty)
-{
-    const auto result_trait = DecimalUtils::binaryOpResult<is_multiply, is_division>(tx, ty);
-    return DecimalType<typename decltype(result_trait)::FieldType>(result_trait.precision, result_trait.scale);
-}
+template <> constexpr size_t DataTypeDecimalBase<Decimal32>::maxPrecision() { return 9; };
+template <> constexpr size_t DataTypeDecimalBase<Decimal64>::maxPrecision() { return 18; };
+template <> constexpr size_t DataTypeDecimalBase<DateTime64>::maxPrecision() { return 18; };
+template <> constexpr size_t DataTypeDecimalBase<Decimal128>::maxPrecision() { return 38; };
+template <> constexpr size_t DataTypeDecimalBase<Decimal256>::maxPrecision() { return 76; };
 
-template <bool is_multiply, bool is_division, typename T, typename U, template <typename> typename DecimalType>
-inline DecimalType<T> decimalResultType(const DecimalType<T> & tx, const DataTypeNumber<U> & ty)
-{
-    const auto result_trait = DecimalUtils::binaryOpResult<is_multiply, is_division>(tx, ty);
-    return DecimalType<typename decltype(result_trait)::FieldType>(result_trait.precision, result_trait.scale);
-}
-
-template <bool is_multiply, bool is_division, typename T, typename U, template <typename> typename DecimalType>
-inline DecimalType<U> decimalResultType(const DataTypeNumber<T> & tx, const DecimalType<U> & ty)
-{
-    const auto result_trait = DecimalUtils::binaryOpResult<is_multiply, is_division>(tx, ty);
-    return DecimalType<typename decltype(result_trait)::FieldType>(result_trait.precision, result_trait.scale);
-}
+extern template class DataTypeDecimalBase<Decimal32>;
+extern template class DataTypeDecimalBase<Decimal64>;
+extern template class DataTypeDecimalBase<DateTime64>;
+extern template class DataTypeDecimalBase<Decimal128>;
+extern template class DataTypeDecimalBase<Decimal256>;
 
 template <template <typename> typename DecimalType>
 inline DataTypePtr createDecimal(UInt64 precision_value, UInt64 scale_value)
 {
-    if (precision_value < DecimalUtils::min_precision || precision_value > DecimalUtils::max_precision<Decimal256>)
+    if (precision_value < 1 || precision_value > DataTypeDecimalBase<Decimal256>::maxPrecision())
         throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Wrong precision: it must be between {} and {}, got {}",
-                        DecimalUtils::min_precision, DecimalUtils::max_precision<Decimal256>, precision_value);
+                        1, DataTypeDecimalBase<Decimal256>::maxPrecision(), precision_value);
 
     if (scale_value > precision_value)
         throw Exception(ErrorCodes::ARGUMENT_OUT_OF_BOUND, "Negative scales and scales larger than precision are not supported");
 
-    if (precision_value <= DecimalUtils::max_precision<Decimal32>)
+    if (precision_value <= DataTypeDecimalBase<Decimal32>::maxPrecision())
         return std::make_shared<DecimalType<Decimal32>>(precision_value, scale_value);
-    if (precision_value <= DecimalUtils::max_precision<Decimal64>)
+    if (precision_value <= DataTypeDecimalBase<Decimal64>::maxPrecision())
         return std::make_shared<DecimalType<Decimal64>>(precision_value, scale_value);
-    if (precision_value <= DecimalUtils::max_precision<Decimal128>)
+    if (precision_value <= DataTypeDecimalBase<Decimal128>::maxPrecision())
         return std::make_shared<DecimalType<Decimal128>>(precision_value, scale_value);
     return std::make_shared<DecimalType<Decimal256>>(precision_value, scale_value);
 }
 
-extern template class DataTypeDecimalBase<Decimal32>;
-extern template class DataTypeDecimalBase<Decimal64>;
-extern template class DataTypeDecimalBase<Decimal128>;
-extern template class DataTypeDecimalBase<Decimal256>;
-extern template class DataTypeDecimalBase<DateTime64>;
-
 }

src/DataTypes/convertMySQLDataType.cpp

@@ -111,13 +111,13 @@ DataTypePtr convertMySQLDataType(MultiEnum<MySQLDataTypesSupport> type_support,
     }
     else if (type_support.isSet(MySQLDataTypesSupport::DECIMAL) && (type_name == "numeric" || type_name == "decimal"))
     {
-        if (precision <= DecimalUtils::max_precision<Decimal32>)
+        if (precision <=  DataTypeDecimalBase<Decimal32>::maxPrecision())
             res = std::make_shared<DataTypeDecimal<Decimal32>>(precision, scale);
-        else if (precision <= DecimalUtils::max_precision<Decimal64>)
+        else if (precision <= DataTypeDecimalBase<Decimal64>::maxPrecision())
             res = std::make_shared<DataTypeDecimal<Decimal64>>(precision, scale);
-        else if (precision <= DecimalUtils::max_precision<Decimal128>)
+        else if (precision <= DataTypeDecimalBase<Decimal128>::maxPrecision())
             res = std::make_shared<DataTypeDecimal<Decimal128>>(precision, scale);
-        else if (precision <= DecimalUtils::max_precision<Decimal256>)
+        else if (precision <= DataTypeDecimalBase<Decimal256>::maxPrecision())
             res = std::make_shared<DataTypeDecimal<Decimal256>>(precision, scale);
     }
     else if (type_name == "point")

src/Dictionaries/getDictionaryConfigurationFromAST.cpp

@@ -493,7 +493,7 @@ void buildConfigurationFromFunctionWithKeyValueArguments(
             /// We assume that function will not take arguments and will return constant value like tcpPort or hostName
             /// Such functions will return column with size equal to input_rows_count.
             size_t input_rows_count = 1;
-            auto result = function->execute({}, function->getResultType(), input_rows_count);
+            auto result = function->execute({}, function->getResultType(), input_rows_count, /* dry_run = */ false);
 
             Field value;
             result->get(0, value);

src/Formats/ProtobufSerializer.cpp

@@ -1308,7 +1308,8 @@ namespace
                         {
                             if (decimal.value == 0)
                                 writeInt(0);
-                            else if (DecimalComparison<DecimalType, int, EqualsOp>::compare(decimal, 1, scale, 0))
+                            else if (DecimalComparison<DecimalType, int, EqualsOp>::compare(
+                                         decimal, 1, scale, 0, /* check overflow */ true))
                                 writeInt(1);
                             else
                             {

src/Functions/CMakeLists.txt

@@ -7,6 +7,7 @@ add_headers_and_sources(clickhouse_functions .)
 # This allows less dependency and linker work (specially important when building many example executables)
 set(DBMS_FUNCTIONS
     IFunction.cpp # IFunctionOverloadResolver::getLambdaArgumentTypes, IExecutableFunction::execute... (Many AST visitors, analyzer passes, some storages...)
+    IFunctionAdaptors.cpp # FunctionToFunctionBaseAdaptor (Used by FunctionFactory.cpp)
     FunctionDynamicAdaptor.cpp # IFunctionOverloadResolver::getLambdaArgumentTypes, IExecutableFunction::execute... (Many AST visitors, analyzer passes, some storages...)
     FunctionFactory.cpp # FunctionFactory::instance() (Many AST visitors, analyzer passes, some storages...)
     FunctionHelpers.cpp # convertConstTupleToConstantElements, checkAndGetColumnConstStringOrFixedString, checkAndGetNestedArrayOffset ...)

src/Functions/FunctionBinaryArithmetic.h

@@ -41,6 +41,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionHelpers.h>
 #include <Functions/IFunction.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <Functions/IsOperation.h>
 #include <Functions/castTypeToEither.h>
 #include <Interpreters/Context.h>
@@ -231,6 +232,27 @@ public:
 namespace impl_
 {
 
+template <bool is_multiply, bool is_division, typename T, typename U, template <typename> typename DecimalType>
+inline auto decimalResultType(const DecimalType<T> & tx, const DecimalType<U> & ty)
+{
+    const auto result_trait = DecimalUtils::binaryOpResult<is_multiply, is_division>(tx, ty);
+    return DecimalType<typename decltype(result_trait)::FieldType>(result_trait.precision, result_trait.scale);
+}
+
+template <bool is_multiply, bool is_division, typename T, typename U, template <typename> typename DecimalType>
+inline DecimalType<T> decimalResultType(const DecimalType<T> & tx, const DataTypeNumber<U> & ty)
+{
+    const auto result_trait = DecimalUtils::binaryOpResult<is_multiply, is_division>(tx, ty);
+    return DecimalType<typename decltype(result_trait)::FieldType>(result_trait.precision, result_trait.scale);
+}
+
+template <bool is_multiply, bool is_division, typename T, typename U, template <typename> typename DecimalType>
+inline DecimalType<U> decimalResultType(const DataTypeNumber<T> & tx, const DecimalType<U> & ty)
+{
+    const auto result_trait = DecimalUtils::binaryOpResult<is_multiply, is_division>(tx, ty);
+    return DecimalType<typename decltype(result_trait)::FieldType>(result_trait.precision, result_trait.scale);
+}
+
 /** Arithmetic operations: +, -, *, /, %,
   * intDiv (integer division)
   * Bitwise operations: |, &, ^, ~.
@@ -1166,7 +1188,7 @@ class FunctionBinaryArithmetic : public IFunction
             new_arguments[1].type = std::make_shared<DataTypeNumber<DataTypeInterval::FieldType>>();
 
         auto function = function_builder->build(new_arguments);
-        return function->execute(new_arguments, result_type, input_rows_count);
+        return function->execute(new_arguments, result_type, input_rows_count, /* dry_run = */ false);
     }
 
     ColumnPtr executeDateTimeTupleOfIntervalsPlusMinus(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type,
@@ -1180,7 +1202,7 @@ class FunctionBinaryArithmetic : public IFunction
 
         auto function = function_builder->build(new_arguments);
 
-        return function->execute(new_arguments, result_type, input_rows_count);
+        return function->execute(new_arguments, result_type, input_rows_count, /* dry_run = */ false);
     }
 
     ColumnPtr executeIntervalTupleOfIntervalsPlusMinus(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type,
@@ -1188,7 +1210,7 @@ class FunctionBinaryArithmetic : public IFunction
     {
         auto function = function_builder->build(arguments);
 
-        return function->execute(arguments, result_type, input_rows_count);
+        return function->execute(arguments, result_type, input_rows_count, /* dry_run = */ false);
     }
 
     ColumnPtr executeArraysImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const
@@ -1323,7 +1345,7 @@ class FunctionBinaryArithmetic : public IFunction
 
         auto function = function_builder->build(new_arguments);
 
-        return function->execute(new_arguments, result_type, input_rows_count);
+        return function->execute(new_arguments, result_type, input_rows_count, /* dry_run = */ false);
     }
 
     template <typename T, typename ResultDataType>
@@ -2225,7 +2247,7 @@ ColumnPtr executeStringInteger(const ColumnsWithTypeAndName & arguments, const A
         /// Special case when the function is plus, minus or multiply, both arguments are tuples.
         if (auto function_builder = getFunctionForTupleArithmetic(arguments[0].type, arguments[1].type, context))
         {
-            return function_builder->build(arguments)->execute(arguments, result_type, input_rows_count);
+            return function_builder->build(arguments)->execute(arguments, result_type, input_rows_count, /* dry_run = */ false);
         }
 
         /// Special case when the function is multiply or divide, one of arguments is Tuple and another is Number.

src/Functions/FunctionFactory.cpp

@@ -1,4 +1,5 @@
 #include <Functions/FunctionFactory.h>
+#include <Functions/IFunctionAdaptors.h>
 
 #include <Interpreters/Context.h>
 

src/Functions/FunctionFactory.h

@@ -5,7 +5,6 @@
 #include <Common/IFactoryWithAliases.h>
 #include <Common/FunctionDocumentation.h>
 #include <Functions/IFunction.h>
-#include <Functions/IFunctionAdaptors.h>
 
 #include <functional>
 #include <memory>

src/Functions/FunctionMathUnary.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Core/callOnTypeIndex.h>
+#include <Core/DecimalFunctions.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypesDecimal.h>
 #include <Columns/ColumnsNumber.h>

src/Functions/FunctionUnaryArithmetic.h

@@ -339,7 +339,7 @@ public:
         /// Special case when the function is negate, argument is tuple.
         if (auto function_builder = getFunctionForTupleArithmetic(arguments[0].type, context))
         {
-            return function_builder->build(arguments)->execute(arguments, result_type, input_rows_count);
+            return function_builder->build(arguments)->execute(arguments, result_type, input_rows_count, /* dry_run = */ false);
         }
 
         ColumnPtr result_column;

src/Functions/FunctionUnixTimestamp64.h

@@ -5,6 +5,7 @@
 #include <Functions/FunctionHelpers.h>
 #include <DataTypes/DataTypeDateTime64.h>
 #include <DataTypes/DataTypesNumber.h>
+#include <Core/DecimalFunctions.h>
 #include <Columns/ColumnsNumber.h>
 #include <Interpreters/Context.h>
 

src/Functions/FunctionsCodingULID.cpp

@@ -2,6 +2,7 @@
 
 #if USE_ULID
 
+#include <Core/DecimalFunctions.h>
 #include <Columns/ColumnFixedString.h>
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnsDateTime.h>

src/Functions/FunctionsComparison.h

@@ -41,12 +41,6 @@
 #include <limits>
 #include <type_traits>
 
-#if USE_EMBEDDED_COMPILER
-#    include <DataTypes/Native.h>
-#    include <llvm/IR/IRBuilder.h>
-#endif
-
-
 namespace DB
 {
 
@@ -59,6 +53,68 @@ namespace ErrorCodes
     extern const int BAD_ARGUMENTS;
 }
 
+template <bool _int, bool _float, bool _decimal, bool _datetime, typename F>
+static inline bool callOnAtLeastOneDecimalType(TypeIndex type_num1, TypeIndex type_num2, F && f)
+{
+    switch (type_num1)
+    {
+        case TypeIndex::DateTime64:
+            return callOnBasicType<DateTime64, _int, _float, _decimal, _datetime>(type_num2, std::forward<F>(f));
+        case TypeIndex::Decimal32:
+            return callOnBasicType<Decimal32, _int, _float, _decimal, _datetime>(type_num2, std::forward<F>(f));
+        case TypeIndex::Decimal64:
+            return callOnBasicType<Decimal64, _int, _float, _decimal, _datetime>(type_num2, std::forward<F>(f));
+        case TypeIndex::Decimal128:
+            return callOnBasicType<Decimal128, _int, _float, _decimal, _datetime>(type_num2, std::forward<F>(f));
+        case TypeIndex::Decimal256:
+            return callOnBasicType<Decimal256, _int, _float, _decimal, _datetime>(type_num2, std::forward<F>(f));
+        default:
+            break;
+    }
+
+    switch (type_num2)
+    {
+        case TypeIndex::DateTime64:
+            return callOnBasicTypeSecondArg<DateTime64, _int, _float, _decimal, _datetime>(type_num1, std::forward<F>(f));
+        case TypeIndex::Decimal32:
+            return callOnBasicTypeSecondArg<Decimal32, _int, _float, _decimal, _datetime>(type_num1, std::forward<F>(f));
+        case TypeIndex::Decimal64:
+            return callOnBasicTypeSecondArg<Decimal64, _int, _float, _decimal, _datetime>(type_num1, std::forward<F>(f));
+        case TypeIndex::Decimal128:
+            return callOnBasicTypeSecondArg<Decimal128, _int, _float, _decimal, _datetime>(type_num1, std::forward<F>(f));
+        case TypeIndex::Decimal256:
+            return callOnBasicTypeSecondArg<Decimal256, _int, _float, _decimal, _datetime>(type_num1, std::forward<F>(f));
+        default:
+            break;
+    }
+
+    return false;
+}
+
+template <template <typename, typename> class Operation, typename Name>
+ColumnPtr executeDecimal(const ColumnWithTypeAndName & col_left, const ColumnWithTypeAndName & col_right, bool check_decimal_overflow)
+{
+    TypeIndex left_number = col_left.type->getTypeId();
+    TypeIndex right_number = col_right.type->getTypeId();
+    ColumnPtr res;
+
+    auto call = [&](const auto & types) -> bool
+    {
+        using Types = std::decay_t<decltype(types)>;
+        using LeftDataType = typename Types::LeftType;
+        using RightDataType = typename Types::RightType;
+
+        return (res = DecimalComparison<LeftDataType, RightDataType, Operation>::apply(col_left, col_right, check_decimal_overflow))
+            != nullptr;
+    };
+
+    if (!callOnAtLeastOneDecimalType<true, false, true, true>(left_number, right_number, call))
+        throw Exception(
+            ErrorCodes::LOGICAL_ERROR, "Wrong call for {} with {} and {}", Name::name, col_left.type->getName(), col_right.type->getName());
+
+    return res;
+}
+
 
 /** Comparison functions: ==, !=, <, >, <=, >=.
   * The comparison functions always return 0 or 1 (UInt8).
@@ -574,62 +630,6 @@ struct GenericComparisonImpl
     }
 };
 
-
-#if USE_EMBEDDED_COMPILER
-
-template <template <typename, typename> typename Op> struct CompileOp;
-
-template <> struct CompileOp<EqualsOp>
-{
-    static llvm::Value * compile(llvm::IRBuilder<> & b, llvm::Value * x, llvm::Value * y, bool /*is_signed*/)
-    {
-        return x->getType()->isIntegerTy() ? b.CreateICmpEQ(x, y) : b.CreateFCmpOEQ(x, y); /// qNaNs always compare false
-    }
-};
-
-template <> struct CompileOp<NotEqualsOp>
-{
-    static llvm::Value * compile(llvm::IRBuilder<> & b, llvm::Value * x, llvm::Value * y, bool /*is_signed*/)
-    {
-        return x->getType()->isIntegerTy() ? b.CreateICmpNE(x, y) : b.CreateFCmpUNE(x, y);
-    }
-};
-
-template <> struct CompileOp<LessOp>
-{
-    static llvm::Value * compile(llvm::IRBuilder<> & b, llvm::Value * x, llvm::Value * y, bool is_signed)
-    {
-        return x->getType()->isIntegerTy() ? (is_signed ? b.CreateICmpSLT(x, y) : b.CreateICmpULT(x, y)) : b.CreateFCmpOLT(x, y);
-    }
-};
-
-template <> struct CompileOp<GreaterOp>
-{
-    static llvm::Value * compile(llvm::IRBuilder<> & b, llvm::Value * x, llvm::Value * y, bool is_signed)
-    {
-        return x->getType()->isIntegerTy() ? (is_signed ? b.CreateICmpSGT(x, y) : b.CreateICmpUGT(x, y)) : b.CreateFCmpOGT(x, y);
-    }
-};
-
-template <> struct CompileOp<LessOrEqualsOp>
-{
-    static llvm::Value * compile(llvm::IRBuilder<> & b, llvm::Value * x, llvm::Value * y, bool is_signed)
-    {
-        return x->getType()->isIntegerTy() ? (is_signed ? b.CreateICmpSLE(x, y) : b.CreateICmpULE(x, y)) : b.CreateFCmpOLE(x, y);
-    }
-};
-
-template <> struct CompileOp<GreaterOrEqualsOp>
-{
-    static llvm::Value * compile(llvm::IRBuilder<> & b, llvm::Value * x, llvm::Value * y, bool is_signed)
-    {
-        return x->getType()->isIntegerTy() ? (is_signed ? b.CreateICmpSGE(x, y) : b.CreateICmpUGE(x, y)) : b.CreateFCmpOGE(x, y);
-    }
-};
-
-#endif
-
-
 struct NameEquals          { static constexpr auto name = "equals"; };
 struct NameNotEquals       { static constexpr auto name = "notEquals"; };
 struct NameLess            { static constexpr auto name = "less"; };
@@ -753,30 +753,6 @@ private:
         return nullptr;
     }
 
-    ColumnPtr executeDecimal(const ColumnWithTypeAndName & col_left, const ColumnWithTypeAndName & col_right) const
-    {
-        TypeIndex left_number = col_left.type->getTypeId();
-        TypeIndex right_number = col_right.type->getTypeId();
-        ColumnPtr res;
-
-        auto call = [&](const auto & types) -> bool
-        {
-            using Types = std::decay_t<decltype(types)>;
-            using LeftDataType = typename Types::LeftType;
-            using RightDataType = typename Types::RightType;
-
-            if (check_decimal_overflow)
-                return (res = DecimalComparison<LeftDataType, RightDataType, Op, true>::apply(col_left, col_right)) != nullptr;
-            return (res = DecimalComparison<LeftDataType, RightDataType, Op, false>::apply(col_left, col_right)) != nullptr;
-        };
-
-        if (!callOnBasicTypes<true, false, true, true>(left_number, right_number, call))
-            throw Exception(ErrorCodes::LOGICAL_ERROR, "Wrong call for {} with {} and {}",
-                            getName(), col_left.type->getName(), col_right.type->getName());
-
-        return res;
-    }
-
     ColumnPtr executeString(const IColumn * c0, const IColumn * c1) const
     {
         const ColumnString * c0_string = checkAndGetColumn<ColumnString>(c0);
@@ -1010,7 +986,7 @@ private:
             convolution_columns[i].type = impl->getResultType();
 
             /// Comparison of the elements.
-            convolution_columns[i].column = impl->execute(tmp_columns, impl->getResultType(), input_rows_count);
+            convolution_columns[i].column = impl->execute(tmp_columns, impl->getResultType(), input_rows_count, /* dry_run = */ false);
         }
 
         if (tuple_size == 1)
@@ -1021,7 +997,7 @@ private:
 
         /// Logical convolution.
         auto impl = func_convolution->build(convolution_columns);
-        return impl->execute(convolution_columns, impl->getResultType(), input_rows_count);
+        return impl->execute(convolution_columns, impl->getResultType(), input_rows_count, /* dry_run = */ false);
     }
 
     ColumnPtr executeTupleLessGreaterImpl(
@@ -1053,18 +1029,18 @@ private:
             {
                 auto impl_head = func_compare_head->build(tmp_columns);
                 less_columns[i].type = impl_head->getResultType();
-                less_columns[i].column = impl_head->execute(tmp_columns, less_columns[i].type, input_rows_count);
+                less_columns[i].column = impl_head->execute(tmp_columns, less_columns[i].type, input_rows_count, /* dry_run = */ false);
 
                 auto impl_equals = func_equals->build(tmp_columns);
                 equal_columns[i].type = impl_equals->getResultType();
-                equal_columns[i].column = impl_equals->execute(tmp_columns, equal_columns[i].type, input_rows_count);
+                equal_columns[i].column = impl_equals->execute(tmp_columns, equal_columns[i].type, input_rows_count, /* dry_run = */ false);
 
             }
             else
             {
                 auto impl_tail = func_compare_tail->build(tmp_columns);
                 less_columns[i].type = impl_tail->getResultType();
-                less_columns[i].column = impl_tail->execute(tmp_columns, less_columns[i].type, input_rows_count);
+                less_columns[i].column = impl_tail->execute(tmp_columns, less_columns[i].type, input_rows_count, /* dry_run = */ false);
             }
         }
 
@@ -1083,13 +1059,13 @@ private:
             tmp_columns[1] = equal_columns[i];
             auto func_and_adaptor = func_and->build(tmp_columns);
 
-            tmp_columns[0].column = func_and_adaptor->execute(tmp_columns, func_and_adaptor->getResultType(), input_rows_count);
+            tmp_columns[0].column = func_and_adaptor->execute(tmp_columns, func_and_adaptor->getResultType(), input_rows_count, /* dry_run = */ false);
             tmp_columns[0].type = func_and_adaptor->getResultType();
 
             tmp_columns[1] = less_columns[i];
             auto func_or_adaptor = func_or->build(tmp_columns);
 
-            tmp_columns[0].column = func_or_adaptor->execute(tmp_columns, func_or_adaptor->getResultType(), input_rows_count);
+            tmp_columns[0].column = func_or_adaptor->execute(tmp_columns, func_or_adaptor->getResultType(), input_rows_count, /* dry_run = */ false);
             tmp_columns[tmp_columns.size() - 1].type = func_or_adaptor->getResultType();
         }
 
@@ -1334,7 +1310,8 @@ public:
                 DataTypePtr common_type = getLeastSupertype(DataTypes{left_type, right_type});
                 ColumnPtr c0_converted = castColumn(col_with_type_and_name_left, common_type);
                 ColumnPtr c1_converted = castColumn(col_with_type_and_name_right, common_type);
-                return executeDecimal({c0_converted, common_type, "left"}, {c1_converted, common_type, "right"});
+                return executeDecimal<Op, Name>(
+                    {c0_converted, common_type, "left"}, {c1_converted, common_type, "right"}, check_decimal_overflow);
             }
 
             /// Check does another data type is comparable to Decimal, includes Int and Float.
@@ -1357,7 +1334,7 @@ public:
                     = ColumnsWithTypeAndName{{c0_converted, converted_type, "left"}, {c1_converted, converted_type, "right"}};
                 return executeImpl(new_arguments, result_type, input_rows_count);
             }
-            return executeDecimal(col_with_type_and_name_left, col_with_type_and_name_right);
+            return executeDecimal<Op, Name>(col_with_type_and_name_left, col_with_type_and_name_right, check_decimal_overflow);
         }
         if (date_and_datetime)
         {
@@ -1367,7 +1344,8 @@ public:
             if (!((res = executeNumLeftType<UInt32>(c0_converted.get(), c1_converted.get()))
                   || (res = executeNumLeftType<UInt64>(c0_converted.get(), c1_converted.get()))
                   || (res = executeNumLeftType<Int32>(c0_converted.get(), c1_converted.get()))
-                  || (res = executeDecimal({c0_converted, common_type, "left"}, {c1_converted, common_type, "right"}))))
+                  || (res = executeDecimal<Op, Name>(
+                          {c0_converted, common_type, "left"}, {c1_converted, common_type, "right"}, check_decimal_overflow))))
                 throw Exception(ErrorCodes::LOGICAL_ERROR, "Date related common types can only be UInt32/UInt64/Int32/Decimal");
             return res;
         }

src/Functions/FunctionsConversion.cpp

@@ -3243,11 +3243,9 @@ private:
     {
         auto function_adaptor = std::make_unique<FunctionToOverloadResolverAdaptor>(function)->build({ColumnWithTypeAndName{nullptr, from_type, ""}});
 
-        return [function_adaptor]
-            (ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, const ColumnNullable *, size_t input_rows_count)
-        {
-            return function_adaptor->execute(arguments, result_type, input_rows_count);
-        };
+        return [function_adaptor](
+                   ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, const ColumnNullable *, size_t input_rows_count)
+        { return function_adaptor->execute(arguments, result_type, input_rows_count, /* dry_run = */ false); };
     }
 
     static WrapperType createToNullableColumnWrapper()

src/Functions/FunctionsExternalDictionaries.h

@@ -644,7 +644,7 @@ private:
         };
 
         auto rows = mask_column->size();
-        result_column = if_func->build(if_args)->execute(if_args, result_type, rows);
+        result_column = if_func->build(if_args)->execute(if_args, result_type, rows, /* dry_run = */ false);
     }
 
 

src/Functions/FunctionsLogical.cpp

@@ -1,5 +1,6 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionsLogical.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <Functions/logical.h>
 
 #include <Columns/ColumnConst.h>

src/Functions/FunctionsOpDate.cpp

@@ -73,7 +73,7 @@ public:
         auto op_build = op->build(arguments);
 
         auto res_type = op_build->getResultType();
-        return op_build->execute(arguments, res_type, input_rows_count);
+        return op_build->execute(arguments, res_type, input_rows_count, /* dry_run = */ false);
     }
 
 private:

src/Functions/IFunction.cpp

@@ -486,6 +486,13 @@ ColumnPtr IExecutableFunction::execute(
     return executeWithoutSparseColumns(arguments, result_type, input_rows_count, dry_run);
 }
 
+ColumnPtr IFunctionBase::execute(const DB::ColumnsWithTypeAndName& arguments, const DB::DataTypePtr& result_type,
+        size_t input_rows_count, bool dry_run) const
+{
+    checkFunctionArgumentSizes(arguments, input_rows_count);
+    return prepare(arguments)->execute(arguments, result_type, input_rows_count, dry_run);
+}
+
 void IFunctionOverloadResolver::checkNumberOfArguments(size_t number_of_arguments) const
 {
     if (isVariadic())

src/Functions/IFunction.h

@@ -7,7 +7,6 @@
 #include <Core/Names.h>
 #include <Core/ValuesWithType.h>
 #include <DataTypes/IDataType.h>
-#include <Functions/FunctionHelpers.h>
 #include <Common/Exception.h>
 
 #include "config.h"
@@ -141,11 +140,7 @@ public:
         const ColumnsWithTypeAndName & arguments,
         const DataTypePtr & result_type,
         size_t input_rows_count,
-        bool dry_run = false) const
-    {
-        checkFunctionArgumentSizes(arguments, input_rows_count);
-        return prepare(arguments)->execute(arguments, result_type, input_rows_count, dry_run);
-    }
+        bool dry_run) const;
 
     /// Get the main function name.
     virtual String getName() const = 0;

src/Functions/IFunctionAdaptors.cpp

@@ -0,0 +1,19 @@
+#include <Functions/FunctionHelpers.h>
+#include <Functions/IFunctionAdaptors.h>
+
+namespace DB
+{
+ColumnPtr FunctionToExecutableFunctionAdaptor::executeImpl(const ColumnsWithTypeAndName& arguments,
+        const DataTypePtr& result_type, size_t input_rows_count) const
+{
+    checkFunctionArgumentSizes(arguments, input_rows_count);
+    return function->executeImpl(arguments, result_type, input_rows_count);
+}
+
+ColumnPtr FunctionToExecutableFunctionAdaptor::executeDryRunImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const
+{
+    checkFunctionArgumentSizes(arguments, input_rows_count);
+    return function->executeImplDryRun(arguments, result_type, input_rows_count);
+}
+
+}

src/Functions/IFunctionAdaptors.h

@@ -16,17 +16,8 @@ public:
 
 protected:
 
-    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const final
-    {
-        checkFunctionArgumentSizes(arguments, input_rows_count);
-        return function->executeImpl(arguments, result_type, input_rows_count);
-    }
-
-    ColumnPtr executeDryRunImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const final
-    {
-        checkFunctionArgumentSizes(arguments, input_rows_count);
-        return function->executeImplDryRun(arguments, result_type, input_rows_count);
-    }
+    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const final;
+    ColumnPtr executeDryRunImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const final;
 
     bool useDefaultImplementationForNulls() const final { return function->useDefaultImplementationForNulls(); }
     bool useDefaultImplementationForNothing() const final { return function->useDefaultImplementationForNothing(); }

src/Functions/Kusto/KqlArraySort.cpp

@@ -117,11 +117,11 @@ public:
         }
 
         auto zipped
-            = FunctionFactory::instance().get("arrayZip", context)->build(new_args)->execute(new_args, result_type, input_rows_count);
+            = FunctionFactory::instance().get("arrayZip", context)->build(new_args)->execute(new_args, result_type, input_rows_count, /* dry_run = */ false);
 
         ColumnsWithTypeAndName sort_arg({{zipped, std::make_shared<DataTypeArray>(result_type), "zipped"}});
         auto sorted_tuple
-            = FunctionFactory::instance().get(sort_function, context)->build(sort_arg)->execute(sort_arg, result_type, input_rows_count);
+            = FunctionFactory::instance().get(sort_function, context)->build(sort_arg)->execute(sort_arg, result_type, input_rows_count, /* dry_run = */ false);
 
         auto null_type = std::make_shared<DataTypeNullable>(std::make_shared<DataTypeInt8>());
 
@@ -140,7 +140,7 @@ public:
                     {null_type->createColumnConstWithDefaultValue(input_rows_count), null_type, "NULL"},
                 });
 
-                tuple_columns[i] = fun_array->build(null_array_arg)->execute(null_array_arg, arg_type, input_rows_count);
+                tuple_columns[i] = fun_array->build(null_array_arg)->execute(null_array_arg, arg_type, input_rows_count, /* dry_run = */ false);
                 tuple_columns[i] = tuple_columns[i]->convertToFullColumnIfConst();
             }
             else
@@ -151,7 +151,7 @@ public:
                 auto tuple_coulmn = FunctionFactory::instance()
                                         .get("tupleElement", context)
                                         ->build(untuple_args)
-                                        ->execute(untuple_args, result_type, input_rows_count);
+                                        ->execute(untuple_args, result_type, input_rows_count, /* dry_run = */ false);
 
                 auto out_tmp = ColumnArray::create(nested_types[i]->createColumn());
 
@@ -190,7 +190,7 @@ public:
             slice_index.column = FunctionFactory::instance()
                                      .get("indexOf", context)
                                      ->build(indexof_args)
-                                     ->execute(indexof_args, result_type, input_rows_count);
+                                     ->execute(indexof_args, result_type, input_rows_count, /* dry_run = */ false);
 
             auto null_index_in_array = slice_index.column->get64(0);
             if (null_index_in_array > 0)
@@ -218,15 +218,15 @@ public:
                         ColumnsWithTypeAndName slice_args_right(
                             {{ColumnWithTypeAndName(tuple_columns[i], arg_type, "array")}, slice_index});
                         ColumnWithTypeAndName arr_left{
-                            fun_slice->build(slice_args_left)->execute(slice_args_left, arg_type, input_rows_count), arg_type, ""};
+                            fun_slice->build(slice_args_left)->execute(slice_args_left, arg_type, input_rows_count, /* dry_run = */ false), arg_type, ""};
                         ColumnWithTypeAndName arr_right{
-                            fun_slice->build(slice_args_right)->execute(slice_args_right, arg_type, input_rows_count), arg_type, ""};
+                            fun_slice->build(slice_args_right)->execute(slice_args_right, arg_type, input_rows_count, /* dry_run = */ false), arg_type, ""};
 
                         ColumnsWithTypeAndName arr_cancat({arr_right, arr_left});
                         auto out_tmp = FunctionFactory::instance()
                                            .get("arrayConcat", context)
                                            ->build(arr_cancat)
-                                           ->execute(arr_cancat, arg_type, input_rows_count);
+                                           ->execute(arr_cancat, arg_type, input_rows_count, /* dry_run = */ false);
                         adjusted_columns[i] = std::move(out_tmp);
                     }
                 }

src/Functions/Kusto/KqlFunctionBase.h

@@ -23,7 +23,7 @@ public:
             {DataTypeUInt8().createColumnConst(1, toField(UInt8(1))), std::make_shared<DataTypeUInt8>(), ""},
             {DataTypeUInt8().createColumnConst(1, toField(UInt8(2))), std::make_shared<DataTypeUInt8>(), ""}
         });
-        auto if_res = FunctionFactory::instance().get("if", context)->build(if_columns)->execute(if_columns, std::make_shared<DataTypeUInt8>(), input_rows_count);
+        auto if_res = FunctionFactory::instance().get("if", context)->build(if_columns)->execute(if_columns, std::make_shared<DataTypeUInt8>(), input_rows_count, /* dry_run = */ false);
         auto result = if_res->getUInt(0);
         return (result == 1);
     }

src/Functions/UserDefined/UserDefinedExecutableFunctionFactory.cpp

@@ -10,10 +10,9 @@
 #include <Processors/Sources/SourceFromSingleChunk.h>
 #include <Formats/formatBlock.h>
 
-#include <Functions/FunctionFactory.h>
 #include <Functions/FunctionHelpers.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <Functions/UserDefined/ExternalUserDefinedExecutableFunctionsLoader.h>
-#include <AggregateFunctions/AggregateFunctionFactory.h>
 #include <Interpreters/convertFieldToType.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/castColumn.h>

src/Functions/array/FunctionsMapMiscellaneous.cpp

@@ -10,6 +10,7 @@
 #include <DataTypes/DataTypeTuple.h>
 
 #include <Functions/FunctionHelpers.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <Functions/like.h>
 #include <Functions/array/arrayConcat.h>
 #include <Functions/array/arrayFilter.h>

src/Functions/array/arrayIntersect.cpp

@@ -339,7 +339,7 @@ static ColumnPtr callFunctionNotEquals(ColumnWithTypeAndName first, ColumnWithTy
 {
     ColumnsWithTypeAndName args{first, second};
     auto eq_func = FunctionFactory::instance().get("notEquals", context)->build(args);
-    return eq_func->execute(args, eq_func->getResultType(), args.front().column->size());
+    return eq_func->execute(args, eq_func->getResultType(), args.front().column->size(), /* dry_run = */ false);
 }
 
 template <typename Mode>

src/Functions/array/arrayJaccardIndex.cpp

@@ -113,7 +113,7 @@ public:
 
         ColumnWithTypeAndName intersect_column;
         intersect_column.type = intersect_array->getResultType();
-        intersect_column.column = intersect_array->execute(arguments, intersect_column.type, input_rows_count);
+        intersect_column.column = intersect_array->execute(arguments, intersect_column.type, input_rows_count, /* dry_run = */ false);
 
         const auto * intersect_column_type = checkAndGetDataType<DataTypeArray>(intersect_column.type.get());
         if (!intersect_column_type)

src/Functions/array/arrayRocAUC.cpp

@@ -58,7 +58,7 @@ namespace ErrorCodes
   * TPR_raw = countIf(score > score_i, label = positive) = count positive labels above certain score
   *
   * Let's look at the example:
-  * arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
+  * arrayRocAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
   *
   * 1. We have pairs: (-, 0.1), (-, 0.4), (+, 0.35), (+, 0.8)
   *
@@ -75,11 +75,11 @@ namespace ErrorCodes
   * The "curve" will be present by a line that moves one step either towards right or top on each threshold change.
   */
 
-class FunctionArrayAUC : public IFunction
+class FunctionArrayRocAUC : public IFunction
 {
 public:
-    static constexpr auto name = "arrayAUC";
-    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayAUC>(); }
+    static constexpr auto name = "arrayRocAUC";
+    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionArrayRocAUC>(); }
 
 private:
     static Float64 apply(
@@ -245,9 +245,11 @@ public:
 };
 
 
-REGISTER_FUNCTION(ArrayAUC)
+REGISTER_FUNCTION(ArrayRocAUC)
 {
-    factory.registerFunction<FunctionArrayAUC>();
+    factory.registerFunction<FunctionArrayRocAUC>();
+    /// Backward compatibility, also the ROC AUC is the more commonly used AUC
+    factory.registerAlias("arrayAUC", "arrayRocAUC");
 }
 
 }

src/Functions/array/arrayWithConstant.cpp

@@ -62,16 +62,17 @@ public:
         for (size_t i = 0; i < num_rows; ++i)
         {
             auto array_size = col_num->getInt(i);
+            auto element_size = col_value->byteSizeAt(i);
 
             if (unlikely(array_size < 0))
                 throw Exception(ErrorCodes::TOO_LARGE_ARRAY_SIZE, "Array size {} cannot be negative: while executing function {}", array_size, getName());
 
             Int64 estimated_size = 0;
-            if (unlikely(common::mulOverflow(array_size, col_value->byteSize(), estimated_size)))
-                throw Exception(ErrorCodes::TOO_LARGE_ARRAY_SIZE, "Array size {} with element size {} bytes is too large: while executing function {}", array_size, col_value->byteSize(), getName());
+            if (unlikely(common::mulOverflow(array_size, element_size, estimated_size)))
+                throw Exception(ErrorCodes::TOO_LARGE_ARRAY_SIZE, "Array size {} with element size {} bytes is too large: while executing function {}", array_size, element_size, getName());
 
             if (unlikely(estimated_size > max_array_size_in_columns_bytes))
-                throw Exception(ErrorCodes::TOO_LARGE_ARRAY_SIZE, "Array size {} with element size {} bytes is too large: while executing function {}", array_size, col_value->byteSize(), getName());
+                throw Exception(ErrorCodes::TOO_LARGE_ARRAY_SIZE, "Array size {} with element size {} bytes is too large: while executing function {}", array_size, element_size, getName());
 
             offset += array_size;
 

src/Functions/array/has.cpp

@@ -1,5 +1,6 @@
 #include "arrayIndex.h"
 #include <Functions/FunctionFactory.h>
+#include <Functions/IFunctionAdaptors.h>
 
 namespace DB
 {

src/Functions/caseWithExpression.cpp

@@ -93,12 +93,12 @@ public:
 
         auto fun_array = FunctionFactory::instance().get("array", context);
 
-        src_array_col.column = fun_array->build(src_array_elems)->execute(src_array_elems, src_array_type, input_rows_count);
-        dst_array_col.column = fun_array->build(dst_array_elems)->execute(dst_array_elems, dst_array_type, input_rows_count);
+        src_array_col.column = fun_array->build(src_array_elems)->execute(src_array_elems, src_array_type, input_rows_count, /* dry_run = */ false);
+        dst_array_col.column = fun_array->build(dst_array_elems)->execute(dst_array_elems, dst_array_type, input_rows_count, /* dry_run = */ false);
 
         /// Execute transform.
         ColumnsWithTypeAndName transform_args{args.front(), src_array_col, dst_array_col, args.back()};
-        return FunctionFactory::instance().get("transform", context)->build(transform_args)->execute(transform_args, result_type, input_rows_count);
+        return FunctionFactory::instance().get("transform", context)->build(transform_args)->execute(transform_args, result_type, input_rows_count, /* dry_run = */ false);
     }
 
 private:

src/Functions/changeDate.cpp

@@ -6,6 +6,7 @@
 #include <Columns/IColumn.h>
 #include <Common/DateLUT.h>
 #include <Common/typeid_cast.h>
+#include <Core/DecimalFunctions.h>
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDate32.h>
 #include <DataTypes/DataTypeDateTime.h>

src/Functions/coalesce.cpp

@@ -133,11 +133,11 @@ public:
             {
                 tmp_args[0] = filtered_args[i];
                 auto & cond = multi_if_args.emplace_back(ColumnWithTypeAndName{nullptr, std::make_shared<DataTypeUInt8>(), ""});
-                cond.column = is_not_null->build(tmp_args)->execute(tmp_args, cond.type, input_rows_count);
+                cond.column = is_not_null->build(tmp_args)->execute(tmp_args, cond.type, input_rows_count, /* dry_run = */ false);
 
                 tmp_args[0] = filtered_args[i];
                 auto & val = multi_if_args.emplace_back(ColumnWithTypeAndName{nullptr, removeNullable(filtered_args[i].type), ""});
-                val.column = assume_not_null->build(tmp_args)->execute(tmp_args, val.type, input_rows_count);
+                val.column = assume_not_null->build(tmp_args)->execute(tmp_args, val.type, input_rows_count, /* dry_run = */ false);
             }
         }
 
@@ -152,7 +152,7 @@ public:
         /// use function "if" instead, because it's implemented more efficient.
         /// TODO: make "multiIf" the same efficient.
         FunctionOverloadResolverPtr if_or_multi_if = multi_if_args.size() == 3 ? if_function : multi_if_function;
-        ColumnPtr res = if_or_multi_if->build(multi_if_args)->execute(multi_if_args, result_type, input_rows_count);
+        ColumnPtr res = if_or_multi_if->build(multi_if_args)->execute(multi_if_args, result_type, input_rows_count, /* dry_run = */ false);
 
         /// if last argument is not nullable, result should be also not nullable
         if (!multi_if_args.back().column->isNullable() && res->isNullable())

src/Functions/concat.cpp

@@ -3,6 +3,7 @@
 #include <DataTypes/DataTypeString.h>
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionHelpers.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <Functions/GatherUtils/Algorithms.h>
 #include <Functions/GatherUtils/Sinks.h>
 #include <Functions/GatherUtils/Sources.h>

src/Functions/date_trunc.cpp

@@ -151,10 +151,10 @@ public:
         auto to_start_of_interval = FunctionFactory::instance().get("toStartOfInterval", context);
 
         if (arguments.size() == 2)
-            return to_start_of_interval->build(temp_columns)->execute(temp_columns, result_type, input_rows_count);
+            return to_start_of_interval->build(temp_columns)->execute(temp_columns, result_type, input_rows_count, /* dry_run = */ false);
 
         temp_columns[2] = arguments[2];
-        return to_start_of_interval->build(temp_columns)->execute(temp_columns, result_type, input_rows_count);
+        return to_start_of_interval->build(temp_columns)->execute(temp_columns, result_type, input_rows_count, /* dry_run = */ false);
     }
 
     bool hasInformationAboutMonotonicity() const override

src/Functions/empty.cpp

@@ -1,6 +1,7 @@
 #include <DataTypes/DataTypeString.h>
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionStringOrArrayToT.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <Functions/EmptyImpl.h>
 #include <Columns/ColumnObject.h>
 

src/Functions/formatRow.cpp

@@ -5,6 +5,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionHelpers.h>
 #include <Functions/IFunction.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <IO/WriteBufferFromVector.h>
 #include <IO/WriteHelpers.h>
 #include <Processors/Formats/IOutputFormat.h>

src/Functions/greater.cpp

@@ -7,6 +7,7 @@ namespace DB
 
 using FunctionGreater = FunctionComparison<GreaterOp, NameGreater>;
 using FunctionEquals = FunctionComparison<EqualsOp, NameEquals>;
+extern template class FunctionComparison<EqualsOp, NameEquals>;
 
 REGISTER_FUNCTION(Greater)
 {

src/Functions/greaterOrEquals.cpp

@@ -2,13 +2,14 @@
 #include <Functions/FunctionsComparison.h>
 #include <Functions/FunctionsLogical.h>
 
-
 namespace DB
 {
 
 using FunctionGreaterOrEquals = FunctionComparison<GreaterOrEqualsOp, NameGreaterOrEquals>;
 using FunctionGreater = FunctionComparison<GreaterOp, NameGreater>;
+extern template class FunctionComparison<GreaterOp, NameGreater>;
 using FunctionEquals = FunctionComparison<EqualsOp, NameEquals>;
+extern template class FunctionComparison<EqualsOp, NameEquals>;
 
 REGISTER_FUNCTION(GreaterOrEquals)
 {

src/Functions/if.cpp

@@ -26,6 +26,7 @@
 #include <Functions/FunctionIfBase.h>
 #include <Functions/GatherUtils/Algorithms.h>
 #include <Functions/IFunction.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/castColumn.h>
 #include <Common/assert_cast.h>

src/Functions/ifNotFinite.cpp

@@ -45,7 +45,7 @@ public:
     {
         ColumnsWithTypeAndName is_finite_columns{arguments[0]};
         auto is_finite = FunctionFactory::instance().get("isFinite", context)->build(is_finite_columns);
-        auto res = is_finite->execute(is_finite_columns, is_finite->getResultType(), input_rows_count);
+        auto res = is_finite->execute(is_finite_columns, is_finite->getResultType(), input_rows_count, /* dry_run = */ false);
 
         ColumnsWithTypeAndName if_columns
         {
@@ -55,7 +55,7 @@ public:
         };
 
         auto func_if = FunctionFactory::instance().get("if", context)->build(if_columns);
-        return func_if->execute(if_columns, result_type, input_rows_count);
+        return func_if->execute(if_columns, result_type, input_rows_count, /* dry_run = */ false);
     }
 
 private:

src/Functions/ifNull.cpp

@@ -66,11 +66,11 @@ public:
 
         auto is_not_null = FunctionFactory::instance().get("isNotNull", context)->build(columns);
         auto is_not_null_type = std::make_shared<DataTypeUInt8>();
-        auto is_not_null_res = is_not_null->execute(columns, is_not_null_type, input_rows_count);
+        auto is_not_null_res = is_not_null->execute(columns, is_not_null_type, input_rows_count, /* dry_run = */ false);
 
         auto assume_not_null = FunctionFactory::instance().get("assumeNotNull", context)->build(columns);
         auto assume_not_null_type = removeNullable(arguments[0].type);
-        auto assume_nut_null_res = assume_not_null->execute(columns, assume_not_null_type, input_rows_count);
+        auto assume_nut_null_res = assume_not_null->execute(columns, assume_not_null_type, input_rows_count, /* dry_run = */ false);
 
         ColumnsWithTypeAndName if_columns
         {
@@ -80,7 +80,7 @@ public:
         };
 
         auto func_if = FunctionFactory::instance().get("if", context)->build(if_columns);
-        return func_if->execute(if_columns, result_type, input_rows_count);
+        return func_if->execute(if_columns, result_type, input_rows_count, /* dry_run = */ false);
     }
 
 private:

src/Functions/isDecimalOverflow.cpp

@@ -7,6 +7,7 @@
 #include <Columns/ColumnDecimal.h>
 #include <Columns/ColumnConst.h>
 #include <Common/intExp.h>
+#include <Core/DecimalFunctions.h>
 
 
 namespace DB

src/Functions/less.cpp

@@ -8,6 +8,7 @@ namespace DB
 
 using FunctionLess = FunctionComparison<LessOp, NameLess>;
 using FunctionEquals = FunctionComparison<EqualsOp, NameEquals>;
+extern template class FunctionComparison<EqualsOp, NameEquals>;
 
 REGISTER_FUNCTION(Less)
 {

src/Functions/lessOrEquals.cpp

@@ -8,7 +8,9 @@ namespace DB
 
 using FunctionLessOrEquals = FunctionComparison<LessOrEqualsOp, NameLessOrEquals>;
 using FunctionLess = FunctionComparison<LessOp, NameLess>;
+extern template class FunctionComparison<LessOp, NameLess>;
 using FunctionEquals = FunctionComparison<EqualsOp, NameEquals>;
+extern template class FunctionComparison<EqualsOp, NameEquals>;
 
 REGISTER_FUNCTION(LessOrEquals)
 {

src/Functions/makeDate.cpp

@@ -10,6 +10,7 @@
 #include <Columns/ColumnDecimal.h>
 #include <Columns/ColumnsDateTime.h>
 #include <Columns/ColumnsNumber.h>
+#include <Core/DecimalFunctions.h>
 #include <Interpreters/castColumn.h>
 
 #include <Common/DateLUT.h>

src/Functions/map.cpp

@@ -133,13 +133,13 @@ public:
         const DataTypePtr & value_array_type = std::make_shared<DataTypeArray>(value_type);
 
         /// key_array = array(args[0], args[2]...)
-        ColumnPtr key_array = function_array->build(key_args)->execute(key_args, key_array_type, input_rows_count);
+        ColumnPtr key_array = function_array->build(key_args)->execute(key_args, key_array_type, input_rows_count, /* dry_run = */ false);
         /// value_array = array(args[1], args[3]...)
-        ColumnPtr value_array = function_array->build(value_args)->execute(value_args, value_array_type, input_rows_count);
+        ColumnPtr value_array = function_array->build(value_args)->execute(value_args, value_array_type, input_rows_count, /* dry_run = */ false);
 
         /// result = mapFromArrays(key_array, value_array)
         ColumnsWithTypeAndName map_args{{key_array, key_array_type, ""}, {value_array, value_array_type, ""}};
-        return function_map_from_arrays->build(map_args)->execute(map_args, result_type, input_rows_count);
+        return function_map_from_arrays->build(map_args)->execute(map_args, result_type, input_rows_count, /* dry_run = */ false);
     }
 
 private:

src/Functions/monthName.cpp

@@ -70,7 +70,7 @@ public:
         };
 
         auto date_name_func = function_resolver->build(temporary_columns);
-        return date_name_func->execute(temporary_columns, result_type, input_rows_count);
+        return date_name_func->execute(temporary_columns, result_type, input_rows_count, /* dry_run = */ false);
     }
 
 private:

src/Functions/multiIf.cpp

@@ -1,5 +1,6 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionIfBase.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <Columns/ColumnNullable.h>
 #include <Columns/ColumnConst.h>
 #include <Columns/ColumnsNumber.h>

src/Functions/multiMatchAny.cpp

@@ -1,6 +1,7 @@
-#include "FunctionsMultiStringSearch.h"
-#include "FunctionFactory.h"
-#include "MultiMatchAnyImpl.h"
+#include <Functions/FunctionsMultiStringSearch.h>
+#include <Functions/FunctionFactory.h>
+#include <Functions/MultiMatchAnyImpl.h>
+#include <Functions/IFunctionAdaptors.h>
 
 
 namespace DB

src/Functions/nullIf.cpp

@@ -49,7 +49,7 @@ public:
         /// nullIf(col1, col2) == if(col1 = col2, NULL, col1)
 
         auto equals_func = FunctionFactory::instance().get("equals", context)->build(arguments);
-        auto eq_res = equals_func->execute(arguments, equals_func->getResultType(), input_rows_count);
+        auto eq_res = equals_func->execute(arguments, equals_func->getResultType(), input_rows_count, /* dry_run = */ false);
 
         ColumnsWithTypeAndName if_columns
         {
@@ -59,7 +59,7 @@ public:
         };
 
         auto func_if = FunctionFactory::instance().get("if", context)->build(if_columns);
-        auto if_res = func_if->execute(if_columns, result_type, input_rows_count);
+        auto if_res = func_if->execute(if_columns, result_type, input_rows_count, /* dry_run = */ false);
 
         return makeNullable(if_res);
     }

src/Functions/printf.cpp

@@ -242,7 +242,7 @@ public:
             }
         }
 
-        auto res = function_concat->build(concat_args)->execute(concat_args, std::make_shared<DataTypeString>(), input_rows_count);
+        auto res = function_concat->build(concat_args)->execute(concat_args, std::make_shared<DataTypeString>(), input_rows_count, /* dry_run = */ false);
         return res;
     }
 

src/Functions/reverse.cpp

@@ -3,6 +3,7 @@
 #include <Columns/ColumnArray.h>
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionHelpers.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <base/map.h>
 #include "reverse.h"
 

src/Functions/splitByRegexp.cpp

@@ -3,6 +3,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionHelpers.h>
 #include <Functions/FunctionTokens.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <Functions/Regexps.h>
 #include <Common/StringUtils.h>
 #include <base/map.h>

src/Functions/toBool.cpp

@@ -55,7 +55,7 @@ namespace
             };
 
             auto func_cast = createInternalCast(arguments[0], result_type, CastType::nonAccurate, {});
-            return func_cast->execute(cast_args, result_type, arguments[0].column->size());
+            return func_cast->execute(cast_args, result_type, arguments[0].column->size(), /* dry_run = */ false);
         }
     };
 }

src/Functions/transform.cpp

@@ -12,6 +12,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionHelpers.h>
 #include <Functions/IFunction.h>
+#include <Functions/IFunctionAdaptors.h>
 #include <Interpreters/castColumn.h>
 #include <Interpreters/convertFieldToType.h>
 #include <Common/HashTable/HashMap.h>
@@ -213,7 +214,7 @@ namespace
 
             auto impl = std::make_shared<FunctionToOverloadResolverAdaptor>(std::make_shared<FunctionTransform>())->build(args);
 
-            return impl->execute(args, result_type, input_rows_count);
+            return impl->execute(args, result_type, input_rows_count, /* dry_run = */ false);
         }
 
         void executeAnything(const IColumn * in, IColumn & column_result, const ColumnPtr default_non_const, const IColumn & in_casted, size_t input_rows_count) const

src/Functions/tupleHammingDistance.cpp

@@ -119,7 +119,7 @@ public:
 
             ColumnWithTypeAndName column;
             column.type = elem_compare->getResultType();
-            column.column = elem_compare->execute({left, right}, column.type, input_rows_count);
+            column.column = elem_compare->execute({left, right}, column.type, input_rows_count, /* dry_run = */ false);
 
             if (i == 0)
             {
@@ -129,7 +129,7 @@ public:
             {
                 auto plus_elem = plus->build({res, column});
                 auto res_type = plus_elem->getResultType();
-                res.column = plus_elem->execute({res, column}, res_type, input_rows_count);
+                res.column = plus_elem->execute({res, column}, res_type, input_rows_count, /* dry_run = */ false);
                 res.type = res_type;
             }
         }

src/Functions/tupleNames.cpp

@@ -4,6 +4,7 @@
 #include <DataTypes/DataTypeString.h>
 #include <DataTypes/DataTypeTuple.h>
 #include <Functions/FunctionFactory.h>
+#include <Functions/FunctionHelpers.h>
 
 namespace DB
 {

src/Functions/vectorFunctions.cpp

@@ -136,7 +136,7 @@ public:
             ColumnWithTypeAndName left{left_elements[i], left_types[i], {}};
             ColumnWithTypeAndName right{right_elements[i], right_types[i], {}};
             auto elem_func = func->build(ColumnsWithTypeAndName{left, right});
-            columns[i] = elem_func->execute({left, right}, elem_func->getResultType(), input_rows_count)
+            columns[i] = elem_func->execute({left, right}, elem_func->getResultType(), input_rows_count, /* dry_run = */ false)
                                   ->convertToFullColumnIfConst();
         }
 
@@ -221,7 +221,7 @@ public:
         {
             ColumnWithTypeAndName cur{cur_elements[i], cur_types[i], {}};
             auto elem_negate = negate->build(ColumnsWithTypeAndName{cur});
-            columns[i] = elem_negate->execute({cur}, elem_negate->getResultType(), input_rows_count)
+            columns[i] = elem_negate->execute({cur}, elem_negate->getResultType(), input_rows_count, /* dry_run = */ false)
                                     ->convertToFullColumnIfConst();
         }
 
@@ -295,7 +295,7 @@ public:
         {
             ColumnWithTypeAndName cur{cur_elements[i], cur_types[i], {}};
             auto elem_func = func->build(ColumnsWithTypeAndName{cur, p_column});
-            columns[i] = elem_func->execute({cur, p_column}, elem_func->getResultType(), input_rows_count)
+            columns[i] = elem_func->execute({cur, p_column}, elem_func->getResultType(), input_rows_count, /* dry_run = */ false)
                                   ->convertToFullColumnIfConst();
         }
 
@@ -413,7 +413,7 @@ public:
 
             ColumnWithTypeAndName column;
             column.type = elem_multiply->getResultType();
-            column.column = elem_multiply->execute({left, right}, column.type, input_rows_count);
+            column.column = elem_multiply->execute({left, right}, column.type, input_rows_count, /* dry_run = */ false);
 
             if (i == 0)
             {
@@ -423,7 +423,7 @@ public:
             {
                 auto plus_elem = plus->build({res, column});
                 auto res_type = plus_elem->getResultType();
-                res.column = plus_elem->execute({res, column}, res_type, input_rows_count);
+                res.column = plus_elem->execute({res, column}, res_type, input_rows_count, /* dry_run = */ false);
                 res.type = res_type;
             }
         }
@@ -510,7 +510,7 @@ public:
             ColumnWithTypeAndName column{cur_elements[i], cur_types[i], {}};
             auto elem_plus = plus->build(ColumnsWithTypeAndName{i == 0 ? arguments[0] : res, column});
             auto res_type = elem_plus->getResultType();
-            res.column = elem_plus->execute({i == 0 ? arguments[0] : res, column}, res_type, input_rows_count);
+            res.column = elem_plus->execute({i == 0 ? arguments[0] : res, column}, res_type, input_rows_count, /* dry_run = */ false);
             res.type = res_type;
         }
 
@@ -665,14 +665,14 @@ public:
             {
                 auto minus = FunctionFactory::instance().get("minus", context);
                 auto elem_minus = minus->build({left, arguments[1]});
-                last_column = elem_minus->execute({left, arguments[1]}, arguments[1].type, input_rows_count)
+                last_column = elem_minus->execute({left, arguments[1]}, arguments[1].type, input_rows_count, /* dry_run = */ false)
                                         ->convertToFullColumnIfConst();
             }
             else
             {
                 auto plus = FunctionFactory::instance().get("plus", context);
                 auto elem_plus = plus->build({left, arguments[1]});
-                last_column = elem_plus->execute({left, arguments[1]}, arguments[1].type, input_rows_count)
+                last_column = elem_plus->execute({left, arguments[1]}, arguments[1].type, input_rows_count, /* dry_run = */ false)
                                         ->convertToFullColumnIfConst();
             }
         }
@@ -682,7 +682,7 @@ public:
             {
                 auto negate = FunctionFactory::instance().get("negate", context);
                 auto elem_negate = negate->build({arguments[1]});
-                last_column = elem_negate->execute({arguments[1]}, arguments[1].type, input_rows_count);
+                last_column = elem_negate->execute({arguments[1]}, arguments[1].type, input_rows_count, /* dry_run = */ false);
             }
             else
             {
@@ -783,7 +783,7 @@ public:
 
             ColumnWithTypeAndName column;
             column.type = elem_abs->getResultType();
-            column.column = elem_abs->execute({cur}, column.type, input_rows_count);
+            column.column = elem_abs->execute({cur}, column.type, input_rows_count, /* dry_run = */ false);
 
             if (i == 0)
             {
@@ -793,7 +793,7 @@ public:
             {
                 auto plus_elem = plus->build({res, column});
                 auto res_type = plus_elem->getResultType();
-                res.column = plus_elem->execute({res, column}, res_type, input_rows_count);
+                res.column = plus_elem->execute({res, column}, res_type, input_rows_count, /* dry_run = */ false);
                 res.type = res_type;
             }
         }
@@ -885,7 +885,7 @@ public:
 
             ColumnWithTypeAndName column;
             column.type = elem_multiply->getResultType();
-            column.column = elem_multiply->execute({cur, cur}, column.type, input_rows_count);
+            column.column = elem_multiply->execute({cur, cur}, column.type, input_rows_count, /* dry_run = */ false);
 
             if (i == 0)
             {
@@ -895,7 +895,7 @@ public:
             {
                 auto plus_elem = plus->build({res, column});
                 auto res_type = plus_elem->getResultType();
-                res.column = plus_elem->execute({res, column}, res_type, input_rows_count);
+                res.column = plus_elem->execute({res, column}, res_type, input_rows_count, /* dry_run = */ false);
                 res.type = res_type;
             }
         }
@@ -949,7 +949,7 @@ public:
 
         auto sqrt = FunctionFactory::instance().get("sqrt", context);
         auto sqrt_elem = sqrt->build({squared_res});
-        return sqrt_elem->execute({squared_res}, sqrt_elem->getResultType(), input_rows_count);
+        return sqrt_elem->execute({squared_res}, sqrt_elem->getResultType(), input_rows_count, /* dry_run = */ false);
     }
 };
 using FunctionL2Norm = FunctionLNorm<L2Label>;
@@ -1036,7 +1036,7 @@ public:
 
             ColumnWithTypeAndName column;
             column.type = elem_abs->getResultType();
-            column.column = elem_abs->execute({cur}, column.type, input_rows_count);
+            column.column = elem_abs->execute({cur}, column.type, input_rows_count, /* dry_run = */ false);
 
             if (i == 0)
             {
@@ -1046,7 +1046,7 @@ public:
             {
                 auto max_elem = max->build({res, column});
                 auto res_type = max_elem->getResultType();
-                res.column = max_elem->execute({res, column}, res_type, input_rows_count);
+                res.column = max_elem->execute({res, column}, res_type, input_rows_count, /* dry_run = */ false);
                 res.type = res_type;
             }
         }
@@ -1163,14 +1163,14 @@ public:
         {
             ColumnWithTypeAndName cur{cur_elements[i], cur_types[i], {}};
             auto elem_abs = abs->build(ColumnsWithTypeAndName{cur});
-            cur.column = elem_abs->execute({cur}, elem_abs->getResultType(), input_rows_count);
+            cur.column = elem_abs->execute({cur}, elem_abs->getResultType(), input_rows_count, /* dry_run = */ false);
             cur.type = elem_abs->getResultType();
 
             auto elem_pow = pow->build(ColumnsWithTypeAndName{cur, p_column});
 
             ColumnWithTypeAndName column;
             column.type = elem_pow->getResultType();
-            column.column = elem_pow->execute({cur, p_column}, column.type, input_rows_count);
+            column.column = elem_pow->execute({cur, p_column}, column.type, input_rows_count, /* dry_run = */ false);
 
             if (i == 0)
             {
@@ -1180,7 +1180,7 @@ public:
             {
                 auto plus_elem = plus->build({res, column});
                 auto res_type = plus_elem->getResultType();
-                res.column = plus_elem->execute({res, column}, res_type, input_rows_count);
+                res.column = plus_elem->execute({res, column}, res_type, input_rows_count, /* dry_run = */ false);
                 res.type = res_type;
             }
         }
@@ -1188,7 +1188,7 @@ public:
         ColumnWithTypeAndName inv_p_column{DataTypeFloat64().createColumnConst(input_rows_count, 1 / p),
                                            std::make_shared<DataTypeFloat64>(), {}};
         auto pow_elem = pow->build({res, inv_p_column});
-        return pow_elem->execute({res, inv_p_column}, pow_elem->getResultType(), input_rows_count);
+        return pow_elem->execute({res, inv_p_column}, pow_elem->getResultType(), input_rows_count, /* dry_run = */ false);
     }
 };
 using FunctionLpNorm = FunctionLNorm<LpLabel>;
@@ -1247,12 +1247,12 @@ public:
         if constexpr (FuncLabel::name[0] == 'p')
         {
             auto func_elem = func->build({minus_res, arguments[2]});
-            return func_elem->execute({minus_res, arguments[2]}, func_elem->getResultType(), input_rows_count);
+            return func_elem->execute({minus_res, arguments[2]}, func_elem->getResultType(), input_rows_count, /* dry_run = */ false);
         }
         else
         {
             auto func_elem = func->build({minus_res});
-            return func_elem->execute({minus_res}, func_elem->getResultType(), input_rows_count);
+            return func_elem->execute({minus_res}, func_elem->getResultType(), input_rows_count, /* dry_run = */ false);
         }
     }
 };
@@ -1394,16 +1394,16 @@ public:
         ColumnWithTypeAndName multiply_result;
         multiply_result.type = multiply_elem->getResultType();
         multiply_result.column = multiply_elem->execute({first_norm, second_norm},
-                                                        multiply_result.type, input_rows_count);
+                                                        multiply_result.type, input_rows_count, /* dry_run = */ false);
 
         auto divide_elem = divide->build({dot_result, multiply_result});
         ColumnWithTypeAndName divide_result;
         divide_result.type = divide_elem->getResultType();
         divide_result.column = divide_elem->execute({dot_result, multiply_result},
-                                                    divide_result.type, input_rows_count);
+                                                    divide_result.type, input_rows_count, /* dry_run = */ false);
 
         auto minus_elem = minus->build({one, divide_result});
-        return minus_elem->execute({one, divide_result}, minus_elem->getResultType(), input_rows_count);
+        return minus_elem->execute({one, divide_result}, minus_elem->getResultType(), input_rows_count, /* dry_run = */ false);
     }
 };
 

src/Interpreters/Access/InterpreterCheckGrantQuery.cpp

@@ -1,25 +1,13 @@
-#include <Interpreters/InterpreterFactory.h>
 #include <Interpreters/Access/InterpreterCheckGrantQuery.h>
-#include <Interpreters/executeQuery.h>
-#include <Parsers/Access/ASTCheckGrantQuery.h>
-#include <Parsers/Access/ASTRolesOrUsersSet.h>
-#include <Access/AccessControl.h>
+
 #include <Access/ContextAccess.h>
-#include <Access/Role.h>
-#include <Access/RolesOrUsersSet.h>
-#include <Access/User.h>
-#include <Interpreters/Context.h>
-#include <Interpreters/removeOnClusterClauseIfNeeded.h>
-#include <Interpreters/QueryLog.h>
-#include <Interpreters/executeDDLQueryOnCluster.h>
-#include <boost/range/algorithm/copy.hpp>
-#include <boost/range/algorithm/set_algorithm.hpp>
-#include <boost/range/algorithm_ext/erase.hpp>
-#include <Interpreters/DatabaseCatalog.h>
 #include <Columns/ColumnsNumber.h>
 #include <DataTypes/DataTypesNumber.h>
+#include <Interpreters/Context.h>
+#include <Interpreters/InterpreterFactory.h>
+#include <Parsers/Access/ASTCheckGrantQuery.h>
 #include <Processors/Sources/SourceFromSingleChunk.h>
-#include "Storages/IStorage.h"
+
 
 namespace DB
 {
@@ -27,21 +15,19 @@ namespace DB
 BlockIO InterpreterCheckGrantQuery::execute()
 {
     auto & query = query_ptr->as<ASTCheckGrantQuery &>();
-    query.access_rights_elements.eraseNonGrantable();
-
-    auto current_user_access = getContext()->getAccess();
 
     /// Collect access rights elements which will be checked.
     AccessRightsElements & elements_to_check_grant = query.access_rights_elements;
-
-    /// Replacing empty database with the default. This step must be done before replication to avoid privilege escalation.
     String current_database = getContext()->getCurrentDatabase();
     elements_to_check_grant.replaceEmptyDatabase(current_database);
-    query.access_rights_elements.replaceEmptyDatabase(current_database);
-    bool user_is_granted = current_user_access->isGranted(elements_to_check_grant);
+
+    auto current_user_access = getContext()->getAccess();
+    bool is_granted = current_user_access->isGranted(elements_to_check_grant);
+
     BlockIO res;
     res.pipeline = QueryPipeline(
-        std::make_shared<SourceFromSingleChunk>(Block{{ColumnUInt8::create(1, user_is_granted), std::make_shared<DataTypeUInt8>(), "result"}}));
+        std::make_shared<SourceFromSingleChunk>(Block{{ColumnUInt8::create(1, is_granted), std::make_shared<DataTypeUInt8>(), "result"}}));
+
     return res;
 }
 

src/Interpreters/Access/InterpreterCheckGrantQuery.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <Core/UUID.h>
 #include <Interpreters/IInterpreter.h>
 #include <Parsers/IAST_fwd.h>
 
@@ -8,10 +7,6 @@
 namespace DB
 {
 
-class ASTCheckGrantQuery;
-struct User;
-struct Role;
-
 class InterpreterCheckGrantQuery : public IInterpreter, WithMutableContext
 {
 public: