Method executeImpl

src/Functions/transform.cpp:169–245

        }

        ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override
        {
            /// If cache was not initialized at build time (e.g. columns were not available during analysis),
            /// initialize it now from the actual arguments.
            std::call_once(cache_once_flag, [&]
            {
                if (!cache)
                    cache = initializeTransformCache(arguments, result_type);
            });

            const auto * in = arguments[0].column.get();

            if (isColumnConst(*in))
                return executeConst(arguments, result_type, input_rows_count);

            ColumnPtr default_non_const;
            if (!cache->default_column && arguments.size() == 4)
            {
                if (arguments[1].column.get()->size() > arguments[3].column.get()->size() || arguments[2].column.get()->size() > arguments[3].column.get()->size())
                {
                    throw Exception(
                        ErrorCodes::BAD_ARGUMENTS,
                        "Fourth argument of function {} must be a constant or at least as big as the second and third arguments",
                        getName());
                }
                default_non_const = castColumn(arguments[3], result_type);
                /// The column might be const on some blocks (e.g. when all values are NULL),
                /// but the code below uses insertFrom which requires matching column types.
                /// Convert to full column to avoid ColumnNullable.insertFrom(ColumnConst) mismatch.
                if (isColumnConst(*default_non_const))
                    default_non_const = default_non_const->convertToFullColumnIfConst();
            }

            ColumnPtr in_cast = arguments[0].column;
            if (arguments.size() == 3)
                in_cast = castColumn(arguments[0], result_type);

            auto column_result = result_type->createColumn();
            if (cache->is_empty)
            {
                return default_non_const
                    ? default_non_const
                    : castColumn(arguments[0], result_type);
            }
            if (cache->table_num_to_idx)
            {
                if (!executeNum<ColumnVector<UInt8>>(in, *column_result, default_non_const, *in_cast, input_rows_count)
                    && !executeNum<ColumnVector<UInt16>>(in, *column_result, default_non_const, *in_cast, input_rows_count)
                    && !executeNum<ColumnVector<UInt32>>(in, *column_result, default_non_const, *in_cast, input_rows_count)
                    && !executeNum<ColumnVector<UInt64>>(in, *column_result, default_non_const, *in_cast, input_rows_count)
                    && !executeNum<ColumnVector<Int8>>(in, *column_result, default_non_const, *in_cast, input_rows_count)
                    && !executeNum<ColumnVector<Int16>>(in, *column_result, default_non_const, *in_cast, input_rows_count)
                    && !executeNum<ColumnVector<Int32>>(in, *column_result, default_non_const, *in_cast, input_rows_count)
                    && !executeNum<ColumnVector<Int64>>(in, *column_result, default_non_const, *in_cast, input_rows_count)
                    && !executeNum<ColumnVector<Float32>>(in, *column_result, default_non_const, *in_cast, input_rows_count)
                    && !executeNum<ColumnVector<Float64>>(in, *column_result, default_non_const, *in_cast, input_rows_count)
                    && !executeNum<ColumnDecimal<Decimal32>>(in, *column_result, default_non_const, *in_cast, input_rows_count)
                    && !executeNum<ColumnDecimal<Decimal64>>(in, *column_result, default_non_const, *in_cast, input_rows_count))