Merge remote-tracking branch 'origin/master' into pr-lazy-materialization

Author: devcrafter

.github/workflows/create_release.yml

@@ -135,9 +135,10 @@ jobs:
           ./utils/list-versions/update-docker-version.sh
           echo "Generate ChangeLog"
           export CI=1
+          docker pull clickhouse/style-test:latest
           docker run -u "${UID}:${GID}" -e PYTHONUNBUFFERED=1 -e CI=1 --network=host \
             --volume=".:/wd" --workdir="/wd" \
-            clickhouse/style-test \
+            clickhouse/style-test:latest \
             ./tests/ci/changelog.py -v --debug-helpers \
             --gh-user-or-token ${{ secrets.ROBOT_CLICKHOUSE_COMMIT_TOKEN }} \
             --jobs=5 \

CHANGELOG.md

@@ -23,7 +23,6 @@
 * Enhance `SummingMergeTree` validation to skip aggregation for columns used in partition or sort keys. [#78022](https://github.com/ClickHouse/ClickHouse/pull/78022) ([Pervakov Grigorii](https://github.com/GrigoryPervakov)).
 
 #### New Feature
-* Support correlated subqueries as an argument of `EXISTS` expression in the `WHERE` clause. Closes [#72459](https://github.com/ClickHouse/ClickHouse/issues/72459). [#76078](https://github.com/ClickHouse/ClickHouse/pull/76078) ([Dmitry Novik](https://github.com/novikd)).
 * Added CPU slot scheduling for workloads, see [the docs](https://clickhouse.com/docs/operations/workload-scheduling#cpu_scheduling) for details. [#77595](https://github.com/ClickHouse/ClickHouse/pull/77595) ([Sergei Trifonov](https://github.com/serxa)).
 * `clickhouse-local` will retain its databases after restart if you specify the `--path` command line argument. This closes [#50647](https://github.com/ClickHouse/ClickHouse/issues/50647). This closes [#49947](https://github.com/ClickHouse/ClickHouse/issues/49947). [#71722](https://github.com/ClickHouse/ClickHouse/pull/71722) ([Alexey Milovidov](https://github.com/alexey-milovidov)).
 * Reject queries when the server is overloaded. The decision is made based on the ratio of wait time (`OSCPUWaitMicroseconds`) to busy time (`OSCPUVirtualTimeMicroseconds`). The query is dropped with some probability, when this ratio is between `min_os_cpu_wait_time_ratio_to_throw` and `max_os_cpu_wait_time_ratio_to_throw` (those are query level settings). [#63206](https://github.com/ClickHouse/ClickHouse/pull/63206) ([Alexey Katsman](https://github.com/alexkats)).
@@ -48,6 +47,7 @@
 * Support password based auth in SSH protocol in ClickHouse. [#78586](https://github.com/ClickHouse/ClickHouse/pull/78586) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)).
 
 #### Experimental Feature
+* Support correlated subqueries as an argument of `EXISTS` expression in the `WHERE` clause. Closes [#72459](https://github.com/ClickHouse/ClickHouse/issues/72459). [#76078](https://github.com/ClickHouse/ClickHouse/pull/76078) ([Dmitry Novik](https://github.com/novikd)).
 * Functions `sparseGrams` and `sparseGramsHashes` with ASCII and UTF8 versions added. Author: [scanhex12](https://github.com/scanhex12). [#78176](https://github.com/ClickHouse/ClickHouse/pull/78176) ([Pervakov Grigorii](https://github.com/GrigoryPervakov)). Do not use it: the implementation will change in the next versions.
 
 #### Performance Improvement
@@ -114,7 +114,7 @@
 
 #### Bug Fix (user-visible misbehavior in an official stable release)
 * Fix incorrect projection analysis when `count(Nullable)` is used in aggregate projections. This fixes [#74495](https://github.com/ClickHouse/ClickHouse/issues/74495) . This PR also adds some logs around projection analysis to clarify why a projection is used or why not. [#74498](https://github.com/ClickHouse/ClickHouse/pull/74498) ([Amos Bird](https://github.com/amosbird)).
-* Fix "Part <...> does not contain in snapshot of previous virtual parts. (PART_IS_TEMPORARILY_LOCKED)" during DETACH PART. [#76039](https://github.com/ClickHouse/ClickHouse/pull/76039) ([Aleksei Filatov](https://github.com/aalexfvk)).
+* Fix `Part <...> does not contain in snapshot of previous virtual parts. (PART_IS_TEMPORARILY_LOCKED)` during `DETACH PART`. [#76039](https://github.com/ClickHouse/ClickHouse/pull/76039) ([Aleksei Filatov](https://github.com/aalexfvk)).
 * Fix not working skip indexes with expression with literals in analyzer and remove trivial casts during indexes analysis. [#77229](https://github.com/ClickHouse/ClickHouse/pull/77229) ([Pavel Kruglov](https://github.com/Avogar)).
 * Fix a bug when `close_session` query parameter didn't have any effect leading to named sessions being closed only after `session_timeout`. [#77336](https://github.com/ClickHouse/ClickHouse/pull/77336) ([Alexey Katsman](https://github.com/alexkats)).
 * Fixed receiving messages from NATS server without attached Materialized Views. [#77392](https://github.com/ClickHouse/ClickHouse/pull/77392) ([Dmitry Novikov](https://github.com/dmitry-sles-novikov)).

ci/docker/style-test/requirements.txt

@@ -3,4 +3,8 @@ yamllint==1.26.3
 codespell==2.2.1
 mypy==1.15.0
 pylint==3.1.0
-tqdm==4.67.1  # required for change log generation
+# required for change log generation:
+tqdm==4.67.1
+thefuzz==0.22.1
+PyGitHub==2.6.1
+boto3==1.37.38

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

@@ -1728,6 +1728,7 @@ distinctdynamictypes
 distinctjsonpaths
 distro
 divideDecimal
+divideOrNull
 dmesg
 doesnt
 domainRFC
@@ -2038,6 +2039,7 @@ inodes
 instantiation
 instantiations
 intDiv
+intDivOrNull
 intDivOrZero
 intExp
 intHash
@@ -2264,6 +2266,7 @@ mmap
 mmapped
 modularization
 moduli
+moduloOrNull
 moduloOrZero
 mongoc
 mongocxx
@@ -2476,6 +2479,7 @@ positionCaseInsensitive
 positionCaseInsensitiveUTF
 positionUTF
 positiveModulo
+positiveModuloOrNull
 postfix
 postfixes
 postgres

contrib/cctz

@@ -93,6 +93,16 @@ divide(a, b)
 
 Alias: `a / b` (operator)
 
+## divideOrNull {#divideornull}
+
+Like [divide](#divide) but returns null when the divisor is zero.
+
+**Syntax**
+
+```sql
+divideOrNull(a, b)
+```
+
 ## intDiv {#intdiv}
 
 Performs an integer division of two values `a` by `b`, i.e. computes the quotient rounded down to the next smallest integer.
@@ -144,6 +154,16 @@ Same as `intDiv` but returns zero when dividing by zero or when dividing a minim
 intDivOrZero(a, b)
 ```
 
+## intDivOrNull {#intdivornull}
+
+Like [intDiv](#intdiv) but returns null when the divisor is zero.
+
+**Syntax**
+
+```sql
+intDivOrNull(a, b)
+```
+
 ## isFinite {#isfinite}
 
 Returns 1 if the Float32 or Float64 argument not infinite and not a NaN, otherwise this function returns 0.
@@ -236,6 +256,16 @@ Like [modulo](#modulo) but returns zero when the divisor is zero.
 moduloOrZero(a, b)
 ```
 
+## moduloOrNull {#moduloornull}
+
+Like [modulo](#modulo) but returns null when the divisor is zero.
+
+**Syntax**
+
+```sql
+moduloOrNull(a, b)
+```
+
 ## positiveModulo(a, b) {#positivemoduloa-b}
 
 Like [modulo](#modulo) but always returns a non-negative number.
@@ -268,6 +298,16 @@ Result:
 └────────────────────────┘
 ```
 
+## positiveModuloOrNull(a, b) {#positivemoduloornulla-b}
+
+Like [positiveModulo](#positivemoduloa-b) but returns null when the divisor is zero.
+
+**Syntax**
+
+```sql
+positiveModuloOrNull(a, b)
+```
+
 ## negate {#negate}
 
 Negates a value `a`. The result is always signed.

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

@@ -500,7 +500,7 @@ The `SHOW CLUSTER(S)` statement returns a list of clusters.
 All available clusters are listed in the [`system.clusters`](../../operations/system-tables/clusters.md) table.
 
 :::note
-The `SHOW CLUSTER name` query displays the contents of `system.clusters` table for the specified cluster name.
+The `SHOW CLUSTER name` query displays `cluster`, `shard_num`, `replica_num`, `host_name`, `host_address`, and `port` of the `system.clusters` table for the specified cluster name.
 :::
 
 ### Syntax {#syntax-20}
@@ -546,16 +546,10 @@ Row 1:
 ──────
 cluster:                 test_shard_localhost
 shard_num:               1
-shard_weight:            1
 replica_num:             1
 host_name:               localhost
 host_address:            127.0.0.1
 port:                    9000
-is_local:                1
-user:                    default
-default_database:
-errors_count:            0
-estimated_recovery_time: 0
 ```
 
 ## SHOW SETTINGS {#show-settings}

docs/en/sql-reference/statements/show.md

@@ -109,6 +109,21 @@ struct DivideIntegralImpl
 #endif
 };
 
+template <typename A, typename B>
+struct DivideIntegralOrNullImpl : DivideIntegralImpl<A, B>
+{
+    using ResultType = typename NumberTraits::ResultOfIntegerDivision<A, B>::Type;
+
+    template<typename Result = ResultType>
+    static Result apply(A a, B b)
+    {
+        if (unlikely(divisionLeadsToFPE(a, b)))
+            return 0;
+        else
+            return DivideIntegralImpl<A, B>::apply(a, b);
+    }
+};
+
 template <typename A, typename B>
 struct ModuloImpl
 {
@@ -168,6 +183,21 @@ struct ModuloLegacyImpl : ModuloImpl<A, B>
     using ResultType = typename NumberTraits::ResultOfModuloLegacy<A, B>::Type;
 };
 
+template <typename A, typename B>
+struct ModuloOrNullImpl : ModuloImpl<A, B>
+{
+    using ResultType = typename NumberTraits::ResultOfModulo<A, B>::Type;
+
+    template <typename Result = ResultType>
+    static Result apply(A a, B b)
+    {
+        if (unlikely(divisionLeadsToFPE(a, b)))
+            return 0;
+        else
+            return ModuloImpl<A, B>::apply(a, b);
+    }
+};
+
 template <typename A, typename B>
 struct PositiveModuloImpl : ModuloImpl<A, B>
 {
@@ -196,4 +226,19 @@ struct PositiveModuloImpl : ModuloImpl<A, B>
     }
 };
 
+template <typename A, typename B>
+struct PositiveModuloOrNullImpl : PositiveModuloImpl<A, B>
+{
+    using ResultType = typename NumberTraits::ResultOfPositiveModulo<A, B>::Type;
+
+    template <typename Result = ResultType>
+    static Result apply(A a, B b)
+    {
+        if (unlikely(divisionLeadsToFPE(a, b)))
+            return 0;
+        else
+            return PositiveModuloImpl<A, B>::apply(a, b);
+    }
+};
+
 }

src/Functions/DivisionUtils.h

@@ -815,6 +815,7 @@ class FunctionBinaryArithmetic : public IFunction
     static constexpr bool is_modulo = IsOperation<Op>::modulo;
     static constexpr bool is_int_div = IsOperation<Op>::int_div;
     static constexpr bool is_int_div_or_zero = IsOperation<Op>::int_div_or_zero;
+    static constexpr bool is_division_or_null = IsOperation<Op>::division_or_null;
 
     ContextPtr context;
     bool check_decimal_overflow = true;
@@ -1615,7 +1616,10 @@ class FunctionBinaryArithmetic : public IFunction
         /// We shouldn't use default implementation for nulls for the case when operation is divide,
         /// intDiv or modulo and denominator is Nullable(Something), because it may cause division
         /// by zero error (when value is Null we store default value 0 in nested column).
-        return !division_by_nullable;
+        /// And we also shouldn't use default implementation for nulls for the case when operation is
+        /// divideOrNull, intDivOrNull, moduloOrNull or positiveModuloOrNull, because it will return
+        /// null when the divisor is zero, and it is conflict with the default implementation.
+        return !division_by_nullable && !is_division_or_null;
     }
 
     bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & arguments) const override
@@ -1926,7 +1930,12 @@ class FunctionBinaryArithmetic : public IFunction
         });
 
         if (valid)
-            return type_res;
+        {
+            if constexpr (is_division_or_null)
+                return makeNullable(type_res);
+            else
+                return type_res;
+        }
 
         throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal types {} and {} of arguments of function {}",
             arguments[0]->getName(), arguments[1]->getName(), String(name));
@@ -2420,7 +2429,6 @@ ColumnPtr executeStringInteger(const ColumnsWithTypeAndName & arguments, const A
         if (division_by_nullable && !right_nullmap)
         {
             assert(right_argument.type->isNullable());
-
             bool is_const = checkColumnConst<ColumnNullable>(right_argument.column.get());
             const ColumnNullable * nullable_column = is_const ? checkAndGetColumnConstData<ColumnNullable>(right_argument.column.get())
                                                               : checkAndGetColumn<ColumnNullable>(right_argument.column.get());
@@ -2430,6 +2438,27 @@ ColumnPtr executeStringInteger(const ColumnsWithTypeAndName & arguments, const A
             return wrapInNullable(res, arguments, result_type, input_rows_count);
         }
 
+        /// Process special case when operation is divideOrNull, intDivOrNull, moduloOrNull or positiveModuloOrNull.
+        if (is_division_or_null)
+        {
+            if (left_argument.column->onlyNull() || right_argument.column->onlyNull())
+            {
+                auto res = removeNullable(result_type)->createColumn();
+                res->insertManyDefaults(input_rows_count);
+                auto null_map_col = ColumnUInt8::create(input_rows_count, 1);
+                return !null_map_col->empty() ? wrapInNullable(std::move(res), std::move(null_map_col)) : makeNullable(std::move(res));
+            }
+            else if (result_type->isNullable())
+            {
+                auto null_map_col = ColumnUInt8::create(input_rows_count, 0);
+                PaddedPODArray<UInt8> & null_map_data = null_map_col->getData();
+                for (size_t i = 0; i < input_rows_count; ++i)
+                    null_map_data[i] = left_argument.column->isNullAt(i) || !right_argument.column->getBool(i);
+                auto res = executeImpl2(createBlockWithNestedColumns(arguments), removeNullable(result_type), input_rows_count, right_nullmap);
+                return !null_map_col->empty() ? wrapInNullable(res, std::move(null_map_col)) : makeNullable(res);
+            }
+        }
+
         /// Special case - one or both arguments are IPv4
         if (isIPv4(arguments[0].type) || isIPv4(arguments[1].type))
         {

src/Functions/FunctionBinaryArithmetic.h

@@ -12,12 +12,16 @@ template <typename, typename> struct PlusImpl;
 template <typename, typename> struct MinusImpl;
 template <typename, typename> struct MultiplyImpl;
 template <typename, typename> struct DivideFloatingImpl;
+template <typename, typename> struct DivideFloatingOrNullImpl;
 template <typename, typename> struct DivideIntegralImpl;
 template <typename, typename> struct DivideIntegralOrZeroImpl;
+template <typename, typename> struct DivideIntegralOrNullImpl;
 template <typename, typename> struct LeastBaseImpl;
 template <typename, typename> struct GreatestBaseImpl;
 template <typename, typename> struct ModuloImpl;
+template <typename, typename> struct ModuloOrNullImpl;
 template <typename, typename> struct PositiveModuloImpl;
+template <typename, typename> struct PositiveModuloOrNullImpl;
 template <typename, typename> struct EqualsOp;
 template <typename, typename> struct NotEqualsOp;
 template <typename, typename> struct LessOrEqualsOp;
@@ -51,10 +55,14 @@ struct IsOperation
     static constexpr bool minus = IsSameOperation<Op, MinusImpl>::value;
     static constexpr bool multiply = IsSameOperation<Op, MultiplyImpl>::value;
     static constexpr bool div_floating = IsSameOperation<Op, DivideFloatingImpl>::value;
+    static constexpr bool div_floating_or_null = IsSameOperation<Op, DivideFloatingOrNullImpl>::value;
     static constexpr bool int_div = IsSameOperation<Op, DivideIntegralImpl>::value;
     static constexpr bool int_div_or_zero = IsSameOperation<Op, DivideIntegralOrZeroImpl>::value;
+    static constexpr bool int_div_or_null = IsSameOperation<Op, DivideIntegralOrNullImpl>::value;
     static constexpr bool modulo = IsSameOperation<Op, ModuloImpl>::value;
+    static constexpr bool modulo_or_null = IsSameOperation<Op, ModuloOrNullImpl>::value;
     static constexpr bool positive_modulo = IsSameOperation<Op, PositiveModuloImpl>::value;
+    static constexpr bool positive_modulo_or_null = IsSameOperation<Op, PositiveModuloOrNullImpl>::value;
     static constexpr bool least = IsSameOperation<Op, LeastBaseImpl>::value;
     static constexpr bool greatest = IsSameOperation<Op, GreatestBaseImpl>::value;
 
@@ -63,6 +71,7 @@ struct IsOperation
     static constexpr bool division = div_floating || int_div || int_div_or_zero || modulo || positive_modulo;
     // NOTE: allow_decimal should not fully contain `division` because of divInt
     static constexpr bool allow_decimal = plus || minus || multiply || division || least || greatest;
+    static constexpr bool division_or_null = modulo_or_null || positive_modulo_or_null || int_div_or_null || div_floating_or_null;
 };
 
 }