ClickHouse · Algunenano · May 13, 2026 · Feb 20, 2026 · Feb 20, 2026 · Feb 20, 2026
diff --git a/.clang-format b/.clang-format
@@ -31,7 +31,7 @@ IndentCaseLabels: true
 SpaceAfterTemplateKeyword: true
 SpaceBeforeCpp11BracedList: false
 SortIncludes: true
-IndentPPDirectives: AfterHash
+IndentPPDirectives: None
 IncludeCategories:
   - Regex: '^<[a-z_]+>'
     Priority: 1

diff --git a/.claude/skills/perf-report/SKILL.md b/.claude/skills/perf-report/SKILL.md
@@ -44,12 +44,12 @@ Do NOT summarize, collapse, or hide entries. Do NOT dismiss anything as "noise"
 
 ### 3. Cross-reference with master history
 
-For every test that shows as slower or faster above 1.10x, check the public CI database to determine if this is a known flaky test or a genuine change introduced by the PR.
+**This step is MANDATORY.** For every test that shows as slower or faster above 1.10x, check the public CI database to determine if this is a known flaky test or a genuine change introduced by the PR. Do NOT skip this step or use alternative approaches (like manually fetching perf reports from other PRs).
 
-Query the public CI database:
+Query the `default.checks` table on `play.clickhouse.com` with `user=explorer`:
 
 ```bash
-clickhouse client --host play.clickhouse.com --user explorer --secure -q "
+clickhouse client --format PrettyCompactNoEscapes --host play.clickhouse.com --user explorer --secure --query "
 SELECT
     replaceRegexpOne(test_name, '::(new|old)$', '') AS test,
     countIf(test_status = 'slower') AS slower_count,
@@ -58,22 +58,25 @@ SELECT
     count() AS total_runs
 FROM default.checks
 WHERE pull_request_number = 0
-  AND check_name LIKE '%Performance%amd%'  -- or arm
+  AND check_name LIKE '%Performance%amd%'
   AND check_start_time >= now() - INTERVAL 30 DAY
   AND test_name IN (
-    'test_name #N::new',
-    ...
+    'norm_distance #2::new',
+    'array_sort #0::new'
   )
 GROUP BY test
 ORDER BY slower_count DESC, test
 "
 ```
 
-**Important:**
-- `pull_request_number = 0` means master commits
-- Test names in the DB have `::new` and `::old` suffixes — query with `::new`
-- Use `%amd%` for AMD results and `%arm%` for ARM results
-- Query both architectures separately
+Run **one query per architecture** — use `'%Performance%amd%'` for x86 and `'%Performance%arm%'` for ARM.
+
+**Critical details:**
+- **Host:** `play.clickhouse.com`, **user:** `explorer` (NOT `play`)
+- **Table:** `default.checks` (NOT `perftest` or other tables)
+- `pull_request_number = 0` filters to master-only commits (no PR noise)
+- Test names in the DB have `::new` and `::old` suffixes — always query with `::new`
+- Include ALL changed tests in a single IN clause to minimize round-trips
 
 ### 4. Classify each change
 

diff --git a/cmake/cpu_features.cmake b/cmake/cpu_features.cmake
@@ -85,27 +85,42 @@ elseif (ARCH_PPC64LE)
 
 elseif (ARCH_AMD64)
     # x86-64 microarchitecture levels (https://en.wikipedia.org/wiki/X86-64#Microarchitecture_levels):
-    #   1 — SSE2 baseline, maximum compatibility with older/embedded hardware
-    #   2 — SSE4.2, SSSE3, POPCNT (default, matches ClickHouse's historical baseline)
-    #   3 — AVX2, BMI1/2, FMA, F16C etc.
-    #   4 — AVX-512F/BW/CD/DQ/VL
-    set (X86_ARCH_LEVEL "2" CACHE STRING "x86-64 microarchitecture level (1, 2, 3, 4)")
+    #   1 - SSE2 baseline, maximum compatibility with older/embedded hardware
+    #   2 - SSE4.2, SSSE3, POPCNT (ClickHouse's historical baseline)
+    #   3 - AVX2, BMI1/2, FMA, F16C, LZCNT, MOVBE etc. (default)
+    #   4 - AVX-512F/BW/CD/DQ/VL
+    set (X86_ARCH_LEVEL "3" CACHE STRING "x86-64 microarchitecture level (1, 2, 3, 4)")
     set_property (CACHE X86_ARCH_LEVEL PROPERTY STRINGS "1" "2" "3" "4")
 
     if (NOT X86_ARCH_LEVEL MATCHES "^[1-4]$")
         message (FATAL_ERROR "X86_ARCH_LEVEL must be one of: 1, 2, 3, 4 (got '${X86_ARCH_LEVEL}')")
     endif ()
 
-    # Same best-effort check for x86 as above for ARM.
+    # Best-effort check: verify that the build host supports the requested microarchitecture level. Build-time tools
+    # (tablegen, code generators) are compiled with these flags and will crash with SIGILL otherwise.
     if (OS_LINUX AND CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64|x86_64" AND X86_ARCH_LEVEL VERSION_GREATER_EQUAL 2)
-        # Test for flags in the default v2 profile.
+        # Test for a representative flag at each level. We intentionally keep this simple - no real CPU has avx2 without
+        # fma/bmi2, so checking the headline flag is enough while avoiding false positives from /proc/cpuinfo quirks
+        # (containers, nested virtualization, unusual flag naming).
+        set (X86_REPRESENTATIVE_FLAG "sse4_2")
+        if (X86_ARCH_LEVEL VERSION_GREATER_EQUAL 3)
+            set (X86_REPRESENTATIVE_FLAG "avx2")
+        endif ()
+        if (X86_ARCH_LEVEL VERSION_GREATER_EQUAL 4)
+            # `x86-64-v4` requires AVX-512 F/BW/CD/DQ/VL. Knights Landing has `avx512f` but lacks BW/DQ/VL, so check one
+            # of those instead - any CPU with `avx512vl` will also have F.
+            set (X86_REPRESENTATIVE_FLAG "avx512vl")
+        endif ()
         execute_process(
-            COMMAND grep -P "^(?=.*ssse3)(?=.*sse4_1)(?=.*sse4_2)" /proc/cpuinfo
+            COMMAND grep -P "(?=.*${X86_REPRESENTATIVE_FLAG})" /proc/cpuinfo
             OUTPUT_VARIABLE FLAGS)
         if (NOT FLAGS)
-            MESSAGE(FATAL_ERROR "The build machine does not satisfy the minimum CPU requirements, try to run cmake with -DX86_ARCH_LEVEL=1")
-        endif()
-    endif()
+            message (FATAL_ERROR
+                "The build machine does not support x86-64-v${X86_ARCH_LEVEL} "
+                "(${X86_REPRESENTATIVE_FLAG} not found in /proc/cpuinfo). "
+                "Run cmake with -DX86_ARCH_LEVEL=<level> to lower the requirement.")
+        endif ()
+    endif ()
 
     # ClickHouse can be cross-compiled (e.g. on an ARM host for x86) but it is also possible to build ClickHouse on x86 w/o AVX for x86 w/
     # AVX. We only assume that the compiler can emit certain SIMD instructions, we don't care if the host system is able to run the binary.
@@ -119,7 +134,6 @@ elseif (ARCH_AMD64)
         set (COMPILER_FLAGS "${COMPILER_FLAGS} -mpclmul")
         list (APPEND RUSTFLAGS_CPU "-C" "target-feature=+pclmulqdq")
     endif ()
-
 else ()
     # RISC-V + exotic platforms
 endif ()
diff --git a/cmake/linux/default_libs.cmake b/cmake/linux/default_libs.cmake
@@ -13,21 +13,8 @@ endif()
 
 if (ENABLE_LLVM_LIBC_MATH)
     link_directories("${CMAKE_BINARY_DIR}/contrib/libllvmlibc-cmake")
-
-    if (ARCH_AMD64)
-        if (X86_ARCH_LEVEL VERSION_LESS 2)
-            # Compat mode: single library, no dispatch
-            target_link_libraries(global-libs INTERFACE libllvmlibc)
-            set (DEFAULT_LIBS "${DEFAULT_LIBS} -llibllvmlibc")
-        else()
-            # Dispatch mode: v2/v3 variants with runtime CPU detection
-            target_link_libraries(global-libs INTERFACE llvmlibc_dispatch libllvmlibc_x86_64_v2 libllvmlibc_x86_64_v3)
-            set (DEFAULT_LIBS "${DEFAULT_LIBS} -lllvmlibc_dispatch -llibllvmlibc_x86_64_v2 -llibllvmlibc_x86_64_v3")
-        endif()
-    elseif (ARCH_AARCH64)
-        target_link_libraries(global-libs INTERFACE libllvmlibc)
-        set (DEFAULT_LIBS "${DEFAULT_LIBS} -llibllvmlibc")
-    endif()
+    target_link_libraries(global-libs INTERFACE libllvmlibc)
+    set (DEFAULT_LIBS "${DEFAULT_LIBS} -llibllvmlibc")
 endif()
 
 if (OS_ANDROID)

diff --git a/cmake/localize_rust_c_symbols.sh b/cmake/localize_rust_c_symbols.sh
@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+#
+# Localize known C library symbols in a Rust static library (.a).
+#
+# Rust static libraries bundle compiler_builtins and libm, which export
+# standard C symbols (cbrt, fma, sin, memcpy, __muloti4, etc.) as globals.
+# When linked before our own C implementations (libllvmlibc, glibc-compat),
+# these silently win — bypassing our -falign-functions=64, -march, and other
+# optimization flags.
+#
+# This script localizes those known C library symbols so the linker picks
+# our own implementations instead.  All other symbols (Rust-mangled, crate
+# FFI, etc.) are left untouched.
+#
+# Usage: localize_rust_c_symbols.sh <library.a> <objcopy>
+
+set -eu
+
+LIB_PATH="$1"
+OBJCOPY="$2"
+
+if [ -z "$LIB_PATH" ] || [ -z "$OBJCOPY" ]; then
+    echo "Usage: $0 <library.a> <objcopy>" >&2
+    exit 1
+fi
+
+if [ ! -f "$LIB_PATH" ]; then
+    echo "Error: Rust library not found: $LIB_PATH" >&2
+    echo "If this is a workspace subcrate, set IMPORTED_LOCATION on the target" >&2
+    echo "before calling clickhouse_config_crate_flags()." >&2
+    exit 1
+fi
+
+# Known C library symbols that Rust's compiler_builtins / libm may export.
+# This list covers:
+#   - C math functions (libm)
+#   - Compiler-rt builtins (__muloti4, __divti3, etc.)
+#   - C string/memory functions that may be provided by Rust
+KNOWN_C_SYMBOLS=(
+    # Math functions (float64)
+    cbrt cos sin tan acos asin atan atan2
+    exp exp2 exp10 log log2 log10 log1p expm1
+    pow sqrt hypot
+    fma fmod remainder
+    ceil floor round trunc nearbyint rint
+    copysign fabs fdim fmax fmin
+    erf erfc tgamma lgamma
+    frexp ldexp modf scalbn ilogb logb
+    nextafter nexttoward
+    # Math functions (float32)
+    cbrtf cosf sinf tanf acosf asinf atanf atan2f
+    expf exp2f exp10f logf log2f log10f log1pf expm1f
+    powf sqrtf hypotf
+    fmaf fmodf remainderf
+    ceilf floorf roundf truncf nearbyintf rintf
+    copysignf fabsf fdimf fmaxf fminf
+    erff erfcf tgammaf lgammaf
+    frexpf ldexpf modff scalbnf ilogbf logbf
+    nextafterf nexttowardf
+    # Math functions (long double)
+    ceill floorl roundl truncl
+    sqrtl frexpl ldexpl scalbnl
+    # Compiler-rt integer builtins
+    __absvdi2 __absvsi2 __absvti2
+    __addvdi3 __addvsi3 __addvti3
+    __cmpdi2 __cmpti2
+    __divdc3 __divsc3
+    __muldc3 __mulsc3
+    __mulvdi3 __mulvsi3 __mulvti3
+    __negdf2 __negsf2 __negdi2 __negti2
+    __negvdi2 __negvsi2 __negvti2
+    __paritydi2 __paritysi2 __parityti2
+    __popcountdi2 __popcountsi2 __popcountti2
+    __muloti4
+)
+
+# Collect which of these actually exist as global symbols in the library
+TMPFILE=$(mktemp)
+WORK_DIR=""
+cleanup() { rm -f "$TMPFILE"; [ -n "$WORK_DIR" ] && rm -rf "$WORK_DIR"; true; }
+trap cleanup EXIT
+
+if ! command -v llvm-nm >/dev/null 2>&1; then
+    echo "Error: llvm-nm not found in PATH (required for Rust C-symbol localization)" >&2
+    exit 1
+fi
+
+# Get all global defined symbols from the library. llvm-nm may print per-member errors for non-ELF archive
+# members (e.g. debug metadata objects) - those are non-fatal as long as at least one ELF member is read.
+# A truly broken/missing archive produces empty output and is caught below.
+llvm-nm "$LIB_PATH" 2>/dev/null \
+    | grep -E '^[0-9a-f]+ [TDBCWV] ' \
+    | awk '{print $3}' \
+    | sort -u \
+    > "$TMPFILE" || true
+
+if [ ! -s "$TMPFILE" ]; then
+    echo "Error: llvm-nm produced no symbols for $LIB_PATH; cannot localize Rust C symbols" >&2
+    exit 1
+fi
+
+# Build objcopy flags for symbols that exist in both lists
+LOCALIZE_FLAGS=""
+for sym in "${KNOWN_C_SYMBOLS[@]}"; do
+    if grep -qxF "$sym" "$TMPFILE"; then
+        LOCALIZE_FLAGS="$LOCALIZE_FLAGS --localize-symbol=$sym"
+    fi
+done
+
+if [ -n "$LOCALIZE_FLAGS" ]; then
+    # Try direct objcopy on the archive first (fast path).
+    # Some Rust archives contain non-ELF members (e.g. debug metadata objects)
+    # that cause llvm-objcopy to fail.  In that case, fall back to extracting
+    # individual members, processing only valid ELF objects, and repacking.
+    if ! $OBJCOPY $LOCALIZE_FLAGS "$LIB_PATH" 2>/dev/null; then
+        # Substitute only inside the basename so a directory containing `objcopy`
+        # is not rewritten and a versioned name like `llvm-objcopy-21` still maps
+        # to `llvm-ar-21`.
+        OBJCOPY_NAME="${OBJCOPY##*/}"
+        AR_NAME="${OBJCOPY_NAME/objcopy/ar}"
+        if [ "$OBJCOPY_NAME" = "$OBJCOPY" ]; then
+            AR="$AR_NAME"
+        else
+            AR="${OBJCOPY%/*}/$AR_NAME"
+        fi
+        WORK_DIR=$(mktemp -d)
+
+        (cd "$WORK_DIR" && "$AR" x "$LIB_PATH")
+        for obj in "$WORK_DIR"/*.o; do
+            $OBJCOPY $LOCALIZE_FLAGS "$obj" 2>/dev/null || true
+        done
+        "$AR" rcs "$LIB_PATH" "$WORK_DIR"/*.o
+    fi
+fi
diff --git a/contrib/corrosion-cmake/CMakeLists.txt b/contrib/corrosion-cmake/CMakeLists.txt
@@ -227,6 +227,7 @@ function(clickhouse_import_crate)
     enable_dummy_launchers_if_needed()
 endfunction()
 
+# Configure a Rust crate target with ClickHouse-specific flags.
 function(clickhouse_config_crate_flags target_name)
     corrosion_set_env_vars(${target_name} "CFLAGS=${RUST_CFLAGS}")
     corrosion_set_env_vars(${target_name} "CXXFLAGS=${RUST_CXXFLAGS}")
@@ -257,4 +258,46 @@ function(clickhouse_config_crate_flags target_name)
     # Refs: https://github.com/rust-lang/cargo/issues/15099#issuecomment-2732847355
     corrosion_set_env_vars(${target_name} "CARGO_NET_OFFLINE=true")
     corrosion_link_libraries(${target_name} cxx)
+
+    # Localize all C-namespace symbols from Rust static libraries so they
+    # don't shadow our own implementations (libllvmlibc, glibc-compat).
+    # Rust's compiler_builtins exports cbrt, fma, sin, etc. as global symbols;
+    # without this, they silently win at link time and bypass our -falign-functions=64
+    # and -march flags, causing performance regressions.
+    #
+    # For workspace crates the .a may land in a parent directory rather than
+    # CMAKE_CURRENT_BINARY_DIR.  Set IMPORTED_LOCATION on the target before
+    # calling this function if the default path is wrong (see wasmtime for an
+    # example).
+    get_target_property(_rust_lib_path ${target_name} IMPORTED_LOCATION)
+    if (NOT _rust_lib_path OR _rust_lib_path MATCHES "NOTFOUND")
+        set(_rust_lib_path "${CMAKE_CURRENT_BINARY_DIR}/lib${target_name}.a")
+    endif()
+
+    # Skip on Darwin (Mach-O), ppc64le (broken .eh_frame), and dummy builds.
+    if (CMAKE_OBJCOPY AND NOT OS_DARWIN
+        AND NOT CMAKE_SYSTEM_PROCESSOR STREQUAL "ppc64le"
+        AND NOT CMAKE_AR MATCHES "dummy_compiler_linker")
+        # Verify the library path looks plausible at configure time.  The file
+        # won't exist yet (cargo hasn't run), but the parent directory must exist
+        # and the filename must end in .a — otherwise someone forgot to set
+        # IMPORTED_LOCATION for a workspace subcrate.
+        get_filename_component(_rust_lib_dir "${_rust_lib_path}" DIRECTORY)
+        if (NOT IS_DIRECTORY "${_rust_lib_dir}")
+            message(FATAL_ERROR
+                "localize_rust_c_symbols: output directory '${_rust_lib_dir}' for "
+                "target '${target_name}' does not exist.  If this is a workspace "
+                "subcrate, set IMPORTED_LOCATION on the target before calling "
+                "clickhouse_config_crate_flags().  Expected library: ${_rust_lib_path}")
+        endif()
+
+        add_custom_target(localize_rust_c_${target_name}
+            COMMAND bash "${ClickHouse_SOURCE_DIR}/cmake/localize_rust_c_symbols.sh"
+                "${_rust_lib_path}" "${CMAKE_OBJCOPY}"
+            COMMENT "Localizing C-namespace symbols in ${target_name}"
+            VERBATIM
+        )
+        add_dependencies(localize_rust_c_${target_name} cargo-build_${target_name})
+        add_dependencies(${target_name} localize_rust_c_${target_name})
+    endif()
 endfunction()
diff --git a/contrib/fastops-cmake/CMakeLists.txt b/contrib/fastops-cmake/CMakeLists.txt
@@ -11,27 +11,33 @@ endif()
 
 set(LIBRARY_DIR "${ClickHouse_SOURCE_DIR}/contrib/fastops")
 
-set(SRCS "")
+set(SRCS
+    "${LIBRARY_DIR}/fastops/fastops.cpp"
+)
 
-if(ARCH_AMD64)
-    set (SRCS ${SRCS} "${LIBRARY_DIR}/fastops/avx/ops_avx.cpp")
-    set_source_files_properties("${LIBRARY_DIR}/fastops/avx/ops_avx.cpp" PROPERTIES COMPILE_FLAGS "-mavx -DNO_AVX2")
-
-    set (SRCS ${SRCS} "${LIBRARY_DIR}/fastops/avx2/ops_avx2.cpp")
-    set_source_files_properties("${LIBRARY_DIR}/fastops/avx2/ops_avx2.cpp" PROPERTIES COMPILE_FLAGS "-mavx2 -mfma")
+if (ARCH_AMD64)
+    list(APPEND SRCS "${LIBRARY_DIR}/fastops/avx2/ops_avx2.cpp")
+endif()
 
-    set (SRCS ${SRCS} "${LIBRARY_DIR}/fastops/plain/ops_plain.cpp" "${LIBRARY_DIR}/fastops/core/avx_id.cpp")
+if (ARCH_AMD64 AND X86_ARCH_LEVEL VERSION_LESS 3)
+    # Below v3: need runtime dispatch with AVX-only and Plain fallbacks.
+    list(APPEND SRCS
+        "${LIBRARY_DIR}/fastops/avx/ops_avx.cpp"
+        "${LIBRARY_DIR}/fastops/plain/ops_plain.cpp"
+        "${LIBRARY_DIR}/fastops/core/avx_id.cpp"
+    )
+    set_source_files_properties("${LIBRARY_DIR}/fastops/avx/ops_avx.cpp" PROPERTIES COMPILE_FLAGS "-mavx -DNO_AVX2")
+    set_source_files_properties("${LIBRARY_DIR}/fastops/avx2/ops_avx2.cpp" PROPERTIES COMPILE_FLAGS "-mavx2 -mfma -DNO_AVX")
 elseif(ARCH_AARCH64)
-    set (SRCS ${SRCS} "${LIBRARY_DIR}/fastops/neon/ops_neon.cpp")
+    list(APPEND SRCS "${LIBRARY_DIR}/fastops/neon/ops_neon.cpp")
 
     # SVE requires arm_sve.h which is only available on Linux toolchains (not Darwin/FreeBSD).
     if(OS_LINUX)
-        set (SRCS ${SRCS} "${LIBRARY_DIR}/fastops/sve/ops_sve.cpp")
+        list(APPEND SRCS "${LIBRARY_DIR}/fastops/sve/ops_sve.cpp")
         set_source_files_properties("${LIBRARY_DIR}/fastops/sve/ops_sve.cpp" PROPERTIES COMPILE_FLAGS "-march=armv8-a+sve")
     endif()
 endif()
 
-set (SRCS ${SRCS} "${LIBRARY_DIR}/fastops/fastops.cpp")
 
 add_library(_fastops ${SRCS})
 

diff --git a/contrib/libdivide-cmake/libdivide-config.h b/contrib/libdivide-cmake/libdivide-config.h
@@ -1,9 +1,9 @@
-#if defined(__SSE2__)
-#    define LIBDIVIDE_SSE2
-#elif defined(__AVX512F__) || defined(__AVX512BW__) || defined(__AVX512VL__)
+#if defined(__AVX512F__) || defined(__AVX512BW__) || defined(__AVX512VL__)
 #    define LIBDIVIDE_AVX512
 #elif defined(__AVX2__)
 #    define LIBDIVIDE_AVX2
+#elif defined(__SSE2__)
+#    define LIBDIVIDE_SSE2
 #elif defined(__aarch64__) && defined(__ARM_NEON)
 #    define LIBDIVIDE_NEON
 #endif