This is an automated email from the ASF dual-hosted git repository.
dataroaring pushed a commit to branch branch-3.0
in repository https://gitbox.apache.org/repos/asf/doris.git
commit 4965e42803bb47bf63870bcbd2b0b497f62df051
Author: Pxl <pxl...@qq.com>
AuthorDate: Mon May 27 10:57:41 2024 +0800
[Chore](column) support all column method on column_fixed_object and remove
some method about IColumn (#35136)
support all column method on column_fixed_object and remove some method
about IColumn
---
be/src/olap/rowset/segment_v2/column_reader.cpp | 2 +-
be/src/olap/rowset/segment_v2/segment_iterator.cpp | 8 +-
.../aggregate_functions/aggregate_function_avg.h | 2 +-
.../aggregate_function_avg_weighted.h | 4 +-
.../aggregate_functions/aggregate_function_covar.h | 8 +-
.../aggregate_function_percentile.h | 46 ++++-----
.../aggregate_function_percentile_approx.h | 8 +-
.../aggregate_function_stddev.h | 8 +-
be/src/vec/columns/column.h | 71 ++------------
be/src/vec/columns/column_array.cpp | 37 -------
be/src/vec/columns/column_array.h | 24 +----
be/src/vec/columns/column_complex.h | 42 --------
be/src/vec/columns/column_const.cpp | 21 ----
be/src/vec/columns/column_const.h | 18 ----
be/src/vec/columns/column_decimal.cpp | 14 ---
be/src/vec/columns/column_decimal.h | 35 -------
be/src/vec/columns/column_dictionary.h | 28 ------
be/src/vec/columns/column_dummy.h | 18 ----
be/src/vec/columns/column_filter_helper.cpp | 5 -
be/src/vec/columns/column_filter_helper.h | 1 -
be/src/vec/columns/column_fixed_length_object.h | 107 +++++++++++----------
be/src/vec/columns/column_impl.h | 41 --------
be/src/vec/columns/column_map.h | 10 --
be/src/vec/columns/column_nullable.cpp | 6 --
be/src/vec/columns/column_nullable.h | 44 +++++----
be/src/vec/columns/column_object.cpp | 10 +-
be/src/vec/columns/column_object.h | 20 ----
be/src/vec/columns/column_string.cpp | 43 ---------
be/src/vec/columns/column_string.h | 23 -----
be/src/vec/columns/column_struct.cpp | 10 --
be/src/vec/columns/column_struct.h | 11 ---
be/src/vec/columns/column_vector.cpp | 15 ---
be/src/vec/columns/column_vector.h | 41 --------
be/src/vec/columns/columns_common.cpp | 29 ------
be/src/vec/columns/columns_common.h | 46 ---------
be/src/vec/columns/predicate_column.h | 43 ---------
be/src/vec/core/block.cpp | 1 -
.../vec/data_types/serde/data_type_time_serde.cpp | 4 +-
.../vec/functions/array/function_array_distance.h | 17 ++--
.../array/function_array_first_or_last_index.cpp | 6 +-
.../vec/functions/array/function_array_shuffle.cpp | 3 +-
be/src/vec/functions/function_case.h | 11 +--
.../function_date_or_datetime_computation.cpp | 54 ++---------
.../function_date_or_datetime_computation.h | 12 ++-
be/src/vec/functions/function_string.h | 5 +-
be/src/vec/functions/functions_geo.cpp | 10 +-
be/src/vec/functions/functions_logical.cpp | 2 +-
be/src/vec/functions/random.cpp | 3 +-
.../data_types/serde/data_type_serde_pb_test.cpp | 2 +-
be/test/vec/exprs/vexpr_test.cpp | 10 +-
.../functions/scalar/CosineDistance.java | 18 ----
.../expressions/functions/scalar/InnerProduct.java | 18 ----
.../expressions/functions/scalar/L1Distance.java | 18 ----
.../expressions/functions/scalar/L2Distance.java | 18 ----
54 files changed, 186 insertions(+), 925 deletions(-)
diff --git a/be/src/olap/rowset/segment_v2/column_reader.cpp
b/be/src/olap/rowset/segment_v2/column_reader.cpp
index a83788a3261..4e005c43a7c 100644
--- a/be/src/olap/rowset/segment_v2/column_reader.cpp
+++ b/be/src/olap/rowset/segment_v2/column_reader.cpp
@@ -880,7 +880,7 @@ Status
OffsetFileColumnIterator::_peek_one_offset(ordinal_t* offset) {
size_t n = 1;
RETURN_IF_ERROR(offset_page_decoder->peek_next_batch(&n, offset_col));
// not null
DCHECK(offset_col->size() == 1);
- *offset = offset_col->get_uint(0);
+ *offset = assert_cast<const
vectorized::ColumnUInt64*>(offset_col.get())->get_element(0);
} else {
*offset =
_offset_iterator->get_current_page()->next_array_item_ordinal;
}
diff --git a/be/src/olap/rowset/segment_v2/segment_iterator.cpp
b/be/src/olap/rowset/segment_v2/segment_iterator.cpp
index 1dd392fefb3..7c6853e9fb3 100644
--- a/be/src/olap/rowset/segment_v2/segment_iterator.cpp
+++ b/be/src/olap/rowset/segment_v2/segment_iterator.cpp
@@ -668,12 +668,8 @@ Status SegmentIterator::_apply_bitmap_index() {
std::vector<ColumnPredicate*> remaining_predicates;
auto is_like_predicate = [](ColumnPredicate* _pred) {
- if (dynamic_cast<LikeColumnPredicate<TYPE_CHAR>*>(_pred) != nullptr ||
- dynamic_cast<LikeColumnPredicate<TYPE_STRING>*>(_pred) != nullptr)
{
- return true;
- }
-
- return false;
+ return dynamic_cast<LikeColumnPredicate<TYPE_CHAR>*>(_pred) != nullptr
||
+ dynamic_cast<LikeColumnPredicate<TYPE_STRING>*>(_pred) !=
nullptr;
};
for (auto pred : _col_predicates) {
auto cid = pred->column_id();
diff --git a/be/src/vec/aggregate_functions/aggregate_function_avg.h
b/be/src/vec/aggregate_functions/aggregate_function_avg.h
index ca155f9d72c..268c2dbf032 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_avg.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_avg.h
@@ -123,7 +123,7 @@ public:
using ColVecResult = std::conditional_t<
IsDecimalV2<T>, ColumnDecimal<Decimal128V2>,
std::conditional_t<IsDecimalNumber<T>, ColumnDecimal<typename
Data::ResultType>,
- ColumnVector<Float64>>>;
+ ColumnFloat64>>;
/// ctor for native types
AggregateFunctionAvg(const DataTypes& argument_types_)
diff --git a/be/src/vec/aggregate_functions/aggregate_function_avg_weighted.h
b/be/src/vec/aggregate_functions/aggregate_function_avg_weighted.h
index e8596a00546..af3b2c98cd8 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_avg_weighted.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_avg_weighted.h
@@ -109,7 +109,7 @@ public:
void add(AggregateDataPtr __restrict place, const IColumn** columns,
ssize_t row_num,
Arena*) const override {
const auto& column = assert_cast<const ColVecType&>(*columns[0]);
- const auto& weight = assert_cast<const
ColumnVector<Float64>&>(*columns[1]);
+ const auto& weight = assert_cast<const ColumnFloat64&>(*columns[1]);
this->data(place).add(column.get_data()[row_num],
weight.get_element(row_num));
}
@@ -130,7 +130,7 @@ public:
}
void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn&
to) const override {
- auto& column = assert_cast<ColumnVector<Float64>&>(to);
+ auto& column = assert_cast<ColumnFloat64&>(to);
column.get_data().push_back(this->data(place).get());
}
};
diff --git a/be/src/vec/aggregate_functions/aggregate_function_covar.h
b/be/src/vec/aggregate_functions/aggregate_function_covar.h
index 31f0d7d2830..c2b5130411b 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_covar.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_covar.h
@@ -211,8 +211,8 @@ struct BaseDatadecimal {
template <typename T, typename Data>
struct PopData : Data {
- using ColVecResult = std::conditional_t<IsDecimalNumber<T>,
ColumnDecimal<Decimal128V2>,
- ColumnVector<Float64>>;
+ using ColVecResult =
+ std::conditional_t<IsDecimalNumber<T>,
ColumnDecimal<Decimal128V2>, ColumnFloat64>;
void insert_result_into(IColumn& to) const {
auto& col = assert_cast<ColVecResult&>(to);
if constexpr (IsDecimalNumber<T>) {
@@ -225,8 +225,8 @@ struct PopData : Data {
template <typename T, typename Data>
struct SampData : Data {
- using ColVecResult = std::conditional_t<IsDecimalNumber<T>,
ColumnDecimal<Decimal128V2>,
- ColumnVector<Float64>>;
+ using ColVecResult =
+ std::conditional_t<IsDecimalNumber<T>,
ColumnDecimal<Decimal128V2>, ColumnFloat64>;
void insert_result_into(IColumn& to) const {
ColumnNullable& nullable_column = assert_cast<ColumnNullable&>(to);
if (this->count == 1 || this->count == 0) {
diff --git a/be/src/vec/aggregate_functions/aggregate_function_percentile.h
b/be/src/vec/aggregate_functions/aggregate_function_percentile.h
index 231057158ce..5984a81109f 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_percentile.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_percentile.h
@@ -182,7 +182,7 @@ public:
if (std::isnan(result)) {
nullable_column.insert_default();
} else {
- auto& col =
assert_cast<ColumnVector<Float64>&>(nullable_column.get_nested_column());
+ auto& col =
assert_cast<ColumnFloat64&>(nullable_column.get_nested_column());
col.get_data().push_back(result);
nullable_column.get_null_map_data().push_back(0);
}
@@ -215,13 +215,13 @@ public:
for (int i = 0; i < 2; ++i) {
const auto* nullable_column =
check_and_get_column<ColumnNullable>(columns[i]);
if (nullable_column == nullptr) { //Not Nullable column
- const auto& column = assert_cast<const
ColumnVector<Float64>&>(*columns[i]);
- column_data[i] = column.get_float64(row_num);
+ const auto& column = assert_cast<const
ColumnFloat64&>(*columns[i]);
+ column_data[i] = column.get_element(row_num);
} else if (!nullable_column->is_null_at(
row_num)) { // Nullable column && Not null
data
- const auto& column = assert_cast<const
ColumnVector<Float64>&>(
- nullable_column->get_nested_column());
- column_data[i] = column.get_float64(row_num);
+ const auto& column =
+ assert_cast<const
ColumnFloat64&>(nullable_column->get_nested_column());
+ column_data[i] = column.get_element(row_num);
} else { // Nullable column && null data
if (i == 0) {
return;
@@ -233,11 +233,11 @@ public:
this->data(place).add(column_data[0], column_data[1]);
} else {
- const auto& sources = assert_cast<const
ColumnVector<Float64>&>(*columns[0]);
- const auto& quantile = assert_cast<const
ColumnVector<Float64>&>(*columns[1]);
+ const auto& sources = assert_cast<const
ColumnFloat64&>(*columns[0]);
+ const auto& quantile = assert_cast<const
ColumnFloat64&>(*columns[1]);
this->data(place).init();
- this->data(place).add(sources.get_float64(row_num),
quantile.get_float64(row_num));
+ this->data(place).add(sources.get_element(row_num),
quantile.get_element(row_num));
}
}
};
@@ -255,13 +255,13 @@ public:
for (int i = 0; i < 3; ++i) {
const auto* nullable_column =
check_and_get_column<ColumnNullable>(columns[i]);
if (nullable_column == nullptr) { //Not Nullable column
- const auto& column = assert_cast<const
ColumnVector<Float64>&>(*columns[i]);
- column_data[i] = column.get_float64(row_num);
+ const auto& column = assert_cast<const
ColumnFloat64&>(*columns[i]);
+ column_data[i] = column.get_element(row_num);
} else if (!nullable_column->is_null_at(
row_num)) { // Nullable column && Not null
data
- const auto& column = assert_cast<const
ColumnVector<Float64>&>(
- nullable_column->get_nested_column());
- column_data[i] = column.get_float64(row_num);
+ const auto& column =
+ assert_cast<const
ColumnFloat64&>(nullable_column->get_nested_column());
+ column_data[i] = column.get_element(row_num);
} else { // Nullable column && null data
if (i == 0) {
return;
@@ -273,12 +273,12 @@ public:
this->data(place).add(column_data[0], column_data[1]);
} else {
- const auto& sources = assert_cast<const
ColumnVector<Float64>&>(*columns[0]);
- const auto& quantile = assert_cast<const
ColumnVector<Float64>&>(*columns[1]);
- const auto& compression = assert_cast<const
ColumnVector<Float64>&>(*columns[2]);
+ const auto& sources = assert_cast<const
ColumnFloat64&>(*columns[0]);
+ const auto& quantile = assert_cast<const
ColumnFloat64&>(*columns[1]);
+ const auto& compression = assert_cast<const
ColumnFloat64&>(*columns[2]);
- this->data(place).init(compression.get_float64(row_num));
- this->data(place).add(sources.get_float64(row_num),
quantile.get_float64(row_num));
+ this->data(place).init(compression.get_element(row_num));
+ this->data(place).add(sources.get_element(row_num),
quantile.get_element(row_num));
}
}
};
@@ -360,7 +360,7 @@ struct PercentileState {
double get() const { return vec_counts[0].terminate(vec_quantile[0]); }
void insert_result_into(IColumn& to) const {
- auto& column_data = assert_cast<ColumnVector<Float64>&>(to).get_data();
+ auto& column_data = assert_cast<ColumnFloat64&>(to).get_data();
for (int i = 0; i < vec_counts.size(); ++i) {
column_data.push_back(vec_counts[i].terminate(vec_quantile[i]));
}
@@ -382,7 +382,7 @@ public:
void add(AggregateDataPtr __restrict place, const IColumn** columns,
ssize_t row_num,
Arena*) const override {
const auto& sources = assert_cast<const ColVecType&>(*columns[0]);
- const auto& quantile = assert_cast<const
ColumnVector<Float64>&>(*columns[1]);
+ const auto& quantile = assert_cast<const ColumnFloat64&>(*columns[1]);
AggregateFunctionPercentile::data(place).add(sources.get_data()[row_num],
quantile.get_data(), 1);
}
@@ -406,7 +406,7 @@ public:
}
void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn&
to) const override {
- auto& col = assert_cast<ColumnVector<Float64>&>(to);
+ auto& col = assert_cast<ColumnFloat64&>(to);
col.insert_value(AggregateFunctionPercentile::data(place).get());
}
};
@@ -434,7 +434,7 @@ public:
const auto& offset_column_data = quantile_array.get_offsets();
const auto& nested_column =
assert_cast<const
ColumnNullable&>(quantile_array.get_data()).get_nested_column();
- const auto& nested_column_data = assert_cast<const
ColumnVector<Float64>&>(nested_column);
+ const auto& nested_column_data = assert_cast<const
ColumnFloat64&>(nested_column);
AggregateFunctionPercentileArray::data(place).add(
sources.get_int(row_num), nested_column_data.get_data(),
diff --git
a/be/src/vec/aggregate_functions/aggregate_function_percentile_approx.h
b/be/src/vec/aggregate_functions/aggregate_function_percentile_approx.h
index 8377153e8ec..7d742ca6d0d 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_percentile_approx.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_percentile_approx.h
@@ -136,7 +136,7 @@ struct OldPercentileState {
double get() const { return vec_counts[0].terminate(vec_quantile[0]); }
void insert_result_into(IColumn& to) const {
- auto& column_data = assert_cast<ColumnVector<Float64>&>(to).get_data();
+ auto& column_data = assert_cast<ColumnFloat64&>(to).get_data();
for (int i = 0; i < vec_counts.size(); ++i) {
column_data.push_back(vec_counts[i].terminate(vec_quantile[i]));
}
@@ -157,7 +157,7 @@ public:
void add(AggregateDataPtr __restrict place, const IColumn** columns,
ssize_t row_num,
Arena*) const override {
const auto& sources = assert_cast<const
ColumnVector<Int64>&>(*columns[0]);
- const auto& quantile = assert_cast<const
ColumnVector<Float64>&>(*columns[1]);
+ const auto& quantile = assert_cast<const ColumnFloat64&>(*columns[1]);
AggregateFunctionPercentileOld::data(place).add(sources.get_int(row_num),
quantile.get_data(),
1);
}
@@ -182,7 +182,7 @@ public:
}
void insert_result_into(ConstAggregateDataPtr __restrict place, IColumn&
to) const override {
- auto& col = assert_cast<ColumnVector<Float64>&>(to);
+ auto& col = assert_cast<ColumnFloat64&>(to);
col.insert_value(AggregateFunctionPercentileOld::data(place).get());
}
};
@@ -208,7 +208,7 @@ public:
const auto& offset_column_data = quantile_array.get_offsets();
const auto& nested_column =
assert_cast<const
ColumnNullable&>(quantile_array.get_data()).get_nested_column();
- const auto& nested_column_data = assert_cast<const
ColumnVector<Float64>&>(nested_column);
+ const auto& nested_column_data = assert_cast<const
ColumnFloat64&>(nested_column);
AggregateFunctionPercentileArrayOld::data(place).add(
sources.get_int(row_num), nested_column_data.get_data(),
diff --git a/be/src/vec/aggregate_functions/aggregate_function_stddev.h
b/be/src/vec/aggregate_functions/aggregate_function_stddev.h
index f095afb41b1..d5150b7bca5 100644
--- a/be/src/vec/aggregate_functions/aggregate_function_stddev.h
+++ b/be/src/vec/aggregate_functions/aggregate_function_stddev.h
@@ -224,8 +224,8 @@ struct BaseDatadecimal {
template <typename T, typename Data>
struct PopData : Data {
- using ColVecResult = std::conditional_t<IsDecimalNumber<T>,
ColumnDecimal<Decimal128V2>,
- ColumnVector<Float64>>;
+ using ColVecResult =
+ std::conditional_t<IsDecimalNumber<T>,
ColumnDecimal<Decimal128V2>, ColumnFloat64>;
void insert_result_into(IColumn& to) const {
auto& col = assert_cast<ColVecResult&>(to);
if constexpr (IsDecimalNumber<T>) {
@@ -258,8 +258,8 @@ struct StddevSampName : Data {
template <typename T, typename Data>
struct SampData : Data {
- using ColVecResult = std::conditional_t<IsDecimalNumber<T>,
ColumnDecimal<Decimal128V2>,
- ColumnVector<Float64>>;
+ using ColVecResult =
+ std::conditional_t<IsDecimalNumber<T>,
ColumnDecimal<Decimal128V2>, ColumnFloat64>;
void insert_result_into(IColumn& to) const {
ColumnNullable& nullable_column = assert_cast<ColumnNullable&>(to);
if (this->count == 1 || this->count == 0) {
diff --git a/be/src/vec/columns/column.h b/be/src/vec/columns/column.h
index 4a889a0e5d0..36b75d54934 100644
--- a/be/src/vec/columns/column.h
+++ b/be/src/vec/columns/column.h
@@ -164,36 +164,11 @@ public:
/// Is used to optimize some computations (in aggregation, for example).
virtual StringRef get_data_at(size_t n) const = 0;
- /// If column stores integers, it returns n-th element transformed to
UInt64 using static_cast.
- /// If column stores floating point numbers, bits of n-th elements are
copied to lower bits of UInt64, the remaining bits are zeros.
- /// Is used to optimize some computations (in aggregation, for example).
- virtual UInt64 get64(size_t /*n*/) const {
- LOG(FATAL) << "Method get64 is not supported for ";
- return 0;
- }
-
- /// If column stores native numeric type, it returns n-th element casted
to Float64
- /// Is used in regression methods to cast each features into uniform type
- virtual Float64 get_float64(size_t /*n*/) const {
- LOG(FATAL) << "Method get_float64 is not supported for " << get_name();
- return 0;
- }
-
- /** If column is numeric, return value of n-th element, casted to UInt64.
- * For NULL values of Nullable column it is allowed to return arbitrary
value.
- * Otherwise throw an exception.
- */
- virtual UInt64 get_uint(size_t /*n*/) const {
- LOG(FATAL) << "Method get_uint is not supported for " << get_name();
- return 0;
- }
-
virtual Int64 get_int(size_t /*n*/) const {
LOG(FATAL) << "Method get_int is not supported for " << get_name();
return 0;
}
- virtual bool is_default_at(size_t n) const { return get64(n) == 0; }
virtual bool is_null_at(size_t /*n*/) const { return false; }
/** If column is numeric, return value of n-th element, casted to bool.
@@ -437,13 +412,6 @@ public:
using Permutation = PaddedPODArray<size_t>;
virtual Ptr permute(const Permutation& perm, size_t limit) const = 0;
- /// Creates new column with values column[indexes[:limit]]. If limit is 0,
all indexes are used.
- /// Indexes must be one of the ColumnUInt. For default implementation, see
select_index_impl from ColumnsCommon.h
- virtual Ptr index(const IColumn& indexes, size_t limit) const {
- LOG(FATAL) << "column not support index";
- __builtin_unreachable();
- }
-
/** Compares (*this)[n] and rhs[m]. Column rhs should have the same type.
* Returns negative number, 0, or positive number (*this)[n] is less,
equal, greater than rhs[m] respectively.
* Is used in sortings.
@@ -456,8 +424,10 @@ public:
* For non Nullable and non floating point types, nan_direction_hint is
ignored.
* For array/map/struct types, we compare with nested column element and
offsets size
*/
- virtual int compare_at(size_t n, size_t m, const IColumn& rhs,
- int nan_direction_hint) const = 0;
+ virtual int compare_at(size_t n, size_t m, const IColumn& rhs, int
nan_direction_hint) const {
+ throw doris::Exception(ErrorCode::NOT_IMPLEMENTED_ERROR,
+ "compare_at for " +
std::string(get_family_name()));
+ }
/**
* To compare all rows in this column with another row (with row_id =
rhs_row_id in column rhs)
@@ -476,7 +446,10 @@ public:
* nan_direction_hint - see above.
*/
virtual void get_permutation(bool reverse, size_t limit, int
nan_direction_hint,
- Permutation& res) const = 0;
+ Permutation& res) const {
+ throw doris::Exception(ErrorCode::NOT_IMPLEMENTED_ERROR,
+ "get_permutation for " +
std::string(get_family_name()));
+ }
/** Copies each element according offsets parameter.
* (i-th element should be copied offsets[i] - offsets[i - 1] times.)
@@ -490,16 +463,6 @@ public:
insert(field);
}
}
- /// Returns indices of values in column, that not equal to default value
of column.
- virtual void get_indices_of_non_default_rows(Offsets64& indices, size_t
from,
- size_t limit) const {
- LOG(FATAL) << "column not support get_indices_of_non_default_rows";
- __builtin_unreachable();
- }
-
- template <typename Derived>
- void get_indices_of_non_default_rows_impl(IColumn::Offsets64& indices,
size_t from,
- size_t limit) const;
/// Returns column with @total_size elements.
/// In result column values from current column are at positions from
@offsets.
@@ -620,9 +583,6 @@ public:
* To avoid confusion between these cases, we don't have isContiguous
method.
*/
- /// Values in column have fixed size (including the case when values span
many memory segments).
- virtual bool values_have_fixed_size() const { return
is_fixed_and_contiguous(); }
-
/// Values in column are represented as continuous memory segment of fixed
size. Implies values_have_fixed_size.
virtual bool is_fixed_and_contiguous() const { return false; }
@@ -640,15 +600,7 @@ public:
/// Returns ratio of values in column, that are equal to default value of
column.
/// Checks only @sample_ratio ratio of rows.
- virtual double get_ratio_of_default_rows(double sample_ratio = 1.0) const {
- LOG(FATAL) << fmt::format("get_ratio_of_default_rows of column {} are
not implemented.",
- get_name());
- return 0.0;
- }
-
- /// Template is to devirtualize calls to 'isDefaultAt' method.
- template <typename Derived>
- double get_ratio_of_default_rows_impl(double sample_ratio) const;
+ virtual double get_ratio_of_default_rows(double sample_ratio = 1.0) const
{ return 0.0; }
/// Column is ColumnVector of numbers or ColumnConst of it. Note that
Nullable columns are not numeric.
/// Implies is_fixed_and_contiguous.
@@ -690,9 +642,6 @@ public:
// ColumnString should replace according to 0,1,2... ,size,0,1,2...
virtual void replace_column_data(const IColumn&, size_t row, size_t
self_row = 0) = 0;
- // only used in ColumnNullable replace_column_data
- virtual void replace_column_data_default(size_t self_row = 0) = 0;
-
virtual void replace_column_null_data(const uint8_t* __restrict null_map)
{}
virtual bool is_date_type() const { return is_date; }
@@ -775,6 +724,6 @@ namespace doris {
struct ColumnPtrWrapper {
vectorized::ColumnPtr column_ptr;
- ColumnPtrWrapper(vectorized::ColumnPtr col) : column_ptr(col) {}
+ ColumnPtrWrapper(vectorized::ColumnPtr col) : column_ptr(std::move(col)) {}
};
} // namespace doris
diff --git a/be/src/vec/columns/column_array.cpp
b/be/src/vec/columns/column_array.cpp
index aba07557e83..cb26aa34814 100644
--- a/be/src/vec/columns/column_array.cpp
+++ b/be/src/vec/columns/column_array.cpp
@@ -54,39 +54,6 @@ extern const int LOGICAL_ERROR;
extern const int TOO_LARGE_ARRAY_SIZE;
} // namespace ErrorCodes
-template <typename T>
-ColumnPtr ColumnArray::index_impl(const PaddedPODArray<T>& indexes, size_t
limit) const {
- assert(limit <= indexes.size());
- if (limit == 0) {
- return ColumnArray::create(data->clone_empty());
- }
- /// Convert indexes to UInt64 in case of overflow.
- auto nested_indexes_column = ColumnUInt64::create();
- PaddedPODArray<UInt64>& nested_indexes = nested_indexes_column->get_data();
- nested_indexes.reserve(get_offsets().back());
- auto res = ColumnArray::create(data->clone_empty());
- Offsets64& res_offsets = res->get_offsets();
- res_offsets.resize(limit);
- size_t current_offset = 0;
- for (size_t i = 0; i < limit; ++i) {
- for (size_t j = 0; j < size_at(indexes[i]); ++j) {
- nested_indexes.push_back(offset_at(indexes[i]) + j);
- }
- current_offset += size_at(indexes[i]);
- res_offsets[i] = current_offset;
- }
- if (current_offset != 0) {
- res->data = data->index(*nested_indexes_column, current_offset);
- }
- return res;
-}
-
-ColumnPtr ColumnArray::index(const IColumn& indexes, size_t limit) const {
- return select_index_impl(*this, indexes, limit);
-}
-
-INSTANTIATE_INDEX_IMPL(ColumnArray)
-
ColumnArray::ColumnArray(MutableColumnPtr&& nested_column, MutableColumnPtr&&
offsets_column)
: data(std::move(nested_column)), offsets(std::move(offsets_column)) {
const ColumnOffsets* offsets_concrete = typeid_cast<const
ColumnOffsets*>(offsets.get());
@@ -551,10 +518,6 @@ void ColumnArray::insert_range_from_ignore_overflow(const
IColumn& src, size_t s
}
}
-double ColumnArray::get_ratio_of_default_rows(double sample_ratio) const {
- return get_ratio_of_default_rows_impl<ColumnArray>(sample_ratio);
-}
-
ColumnPtr ColumnArray::filter(const Filter& filt, ssize_t result_size_hint)
const {
if (typeid_cast<const ColumnUInt8*>(data.get()))
return filter_number<UInt8>(filt, result_size_hint);
diff --git a/be/src/vec/columns/column_array.h
b/be/src/vec/columns/column_array.h
index 2d86bb8c546..927a72c0e4f 100644
--- a/be/src/vec/columns/column_array.h
+++ b/be/src/vec/columns/column_array.h
@@ -136,7 +136,7 @@ public:
Field operator[](size_t n) const override;
void get(size_t n, Field& res) const override;
StringRef get_data_at(size_t n) const override;
- bool is_default_at(size_t n) const override;
+ bool is_default_at(size_t n) const;
void insert_data(const char* pos, size_t length) override;
StringRef serialize_value_into_arena(size_t n, Arena& arena, char const*&
begin) const override;
const char* deserialize_and_insert_from_arena(const char* pos) override;
@@ -163,16 +163,7 @@ public:
ColumnPtr filter(const Filter& filt, ssize_t result_size_hint) const
override;
size_t filter(const Filter& filter) override;
ColumnPtr permute(const Permutation& perm, size_t limit) const override;
- //ColumnPtr index(const IColumn & indexes, size_t limit) const;
- template <typename Type>
- ColumnPtr index_impl(const PaddedPODArray<Type>& indexes, size_t limit)
const;
int compare_at(size_t n, size_t m, const IColumn& rhs_, int
nan_direction_hint) const override;
-
- [[noreturn]] void get_permutation(bool reverse, size_t limit, int
nan_direction_hint,
- Permutation& res) const override {
- LOG(FATAL) << "get_permutation not implemented";
- __builtin_unreachable();
- }
void reserve(size_t n) override;
size_t byte_size() const override;
size_t allocated_bytes() const override;
@@ -233,10 +224,6 @@ public:
LOG(FATAL) << "Method replace_column_data is not supported for " <<
get_name();
}
- void replace_column_data_default(size_t self_row = 0) override {
- LOG(FATAL) << "Method replace_column_data_default is not supported for
" << get_name();
- }
-
void clear() override {
data->clear();
offsets->clear();
@@ -252,15 +239,6 @@ public:
->get_number_of_dimensions(); /// Every modern C++
compiler optimizes tail recursion.
}
- void get_indices_of_non_default_rows(Offsets64& indices, size_t from,
- size_t limit) const override {
- return get_indices_of_non_default_rows_impl<ColumnArray>(indices,
from, limit);
- }
-
- ColumnPtr index(const IColumn& indexes, size_t limit) const override;
-
- double get_ratio_of_default_rows(double sample_ratio) const override;
-
private:
// [[2,1,5,9,1], [1,2,4]] --> data column [2,1,5,9,1,1,2,4], offset[-1] =
0, offset[0] = 5, offset[1] = 8
// [[[2,1,5],[9,1]], [[1,2]]] --> data column [3 column array], offset[-1]
= 0, offset[0] = 2, offset[1] = 3
diff --git a/be/src/vec/columns/column_complex.h
b/be/src/vec/columns/column_complex.h
index 193834c80f1..f173a1bf49b 100644
--- a/be/src/vec/columns/column_complex.h
+++ b/be/src/vec/columns/column_complex.h
@@ -121,22 +121,6 @@ public:
void insert_value(T value) { data.emplace_back(std::move(value)); }
- [[noreturn]] void get_permutation(bool reverse, size_t limit, int
nan_direction_hint,
- IColumn::Permutation& res) const
override {
- LOG(FATAL) << "get_permutation not implemented";
- __builtin_unreachable();
- }
-
- void get_indices_of_non_default_rows(IColumn::Offsets64& indices, size_t
from,
- size_t limit) const override {
- LOG(FATAL) << "get_indices_of_non_default_rows not implemented";
- __builtin_unreachable();
- }
- [[noreturn]] ColumnPtr index(const IColumn& indexes, size_t limit) const
override {
- LOG(FATAL) << "index not implemented";
- __builtin_unreachable();
- }
-
void reserve(size_t n) override { data.reserve(n); }
void resize(size_t n) override { data.resize(n); }
@@ -160,21 +144,6 @@ public:
res.assign_string(reinterpret_cast<const char*>(&data[n]),
sizeof(data[n]));
}
- [[noreturn]] UInt64 get64(size_t n) const override {
- LOG(FATAL) << "get field not implemented";
- __builtin_unreachable();
- }
-
- [[noreturn]] Float64 get_float64(size_t n) const override {
- LOG(FATAL) << "get field not implemented";
- __builtin_unreachable();
- }
-
- [[noreturn]] UInt64 get_uint(size_t n) const override {
- LOG(FATAL) << "get field not implemented";
- __builtin_unreachable();
- }
-
[[noreturn]] bool get_bool(size_t n) const override {
LOG(FATAL) << "get field not implemented";
__builtin_unreachable();
@@ -227,12 +196,6 @@ public:
// TODO add hash function
}
- [[noreturn]] int compare_at(size_t n, size_t m, const IColumn& rhs,
- int nan_direction_hint) const override {
- throw doris::Exception(ErrorCode::NOT_IMPLEMENTED_ERROR,
- "compare_at for " +
std::string(get_family_name()));
- }
-
bool is_fixed_and_contiguous() const override { return true; }
size_t size_of_value_if_fixed() const override { return sizeof(T); }
@@ -275,11 +238,6 @@ public:
data[self_row] = assert_cast<const Self&>(rhs).data[row];
}
- void replace_column_data_default(size_t self_row = 0) override {
- DCHECK(size() > self_row);
- data[self_row] = T();
- }
-
private:
Container data;
};
diff --git a/be/src/vec/columns/column_const.cpp
b/be/src/vec/columns/column_const.cpp
index 7efc7fef9b4..061c8650c24 100644
--- a/be/src/vec/columns/column_const.cpp
+++ b/be/src/vec/columns/column_const.cpp
@@ -134,27 +134,6 @@ void ColumnConst::get_permutation(bool /*reverse*/, size_t
/*limit*/, int /*nan_
}
}
-void ColumnConst::get_indices_of_non_default_rows(Offsets64& indices, size_t
from,
- size_t limit) const {
- if (!data->is_default_at(0)) {
- size_t to = limit && from + limit < size() ? from + limit : size();
- indices.reserve(indices.size() + to - from);
- for (size_t i = from; i < to; ++i) {
- indices.push_back(i);
- }
- }
-}
-
-ColumnPtr ColumnConst::index(const IColumn& indexes, size_t limit) const {
- if (limit == 0) {
- limit = indexes.size();
- }
- if (indexes.size() < limit) {
- LOG(FATAL) << "Size of indexes is less than required " <<
std::to_string(limit);
- }
- return ColumnConst::create(data, limit);
-}
-
std::pair<ColumnPtr, size_t> check_column_const_set_readability(const IColumn&
column,
size_t
row_num) noexcept {
std::pair<ColumnPtr, size_t> result;
diff --git a/be/src/vec/columns/column_const.h
b/be/src/vec/columns/column_const.h
index 14fa5d6b191..2a67b319e42 100644
--- a/be/src/vec/columns/column_const.h
+++ b/be/src/vec/columns/column_const.h
@@ -127,16 +127,10 @@ public:
StringRef get_data_at(size_t) const override { return
data->get_data_at(0); }
- UInt64 get64(size_t) const override { return data->get64(0); }
-
- UInt64 get_uint(size_t) const override { return data->get_uint(0); }
-
Int64 get_int(size_t) const override { return data->get_int(0); }
bool get_bool(size_t) const override { return data->get_bool(0); }
- Float64 get_float64(size_t) const override { return data->get_float64(0); }
-
bool is_null_at(size_t) const override { return data->is_null_at(0); }
void insert_range_from(const IColumn&, size_t /*start*/, size_t length)
override {
@@ -160,11 +154,6 @@ public:
void pop_back(size_t n) override { s -= n; }
- void get_indices_of_non_default_rows(Offsets64& indices, size_t from,
- size_t limit) const override;
-
- ColumnPtr index(const IColumn& indexes, size_t limit) const override;
-
StringRef serialize_value_into_arena(size_t, Arena& arena, char const*&
begin) const override {
return data->serialize_value_into_arena(0, arena, begin);
}
@@ -271,7 +260,6 @@ public:
bool only_null() const override { return data->is_null_at(0); }
bool is_numeric() const override { return data->is_numeric(); }
bool is_fixed_and_contiguous() const override { return
data->is_fixed_and_contiguous(); }
- bool values_have_fixed_size() const override { return
data->values_have_fixed_size(); }
size_t size_of_value_if_fixed() const override { return
data->size_of_value_if_fixed(); }
StringRef get_raw_data() const override { return data->get_raw_data(); }
@@ -292,11 +280,5 @@ public:
DCHECK(size() > self_row);
data->replace_column_data(rhs, row, self_row);
}
-
- void replace_column_data_default(size_t self_row = 0) override {
- DCHECK(size() > self_row);
- LOG(FATAL) << "should not call the method in column const";
- __builtin_unreachable();
- }
};
} // namespace doris::vectorized
diff --git a/be/src/vec/columns/column_decimal.cpp
b/be/src/vec/columns/column_decimal.cpp
index 5d90b66b8e2..420984bf83c 100644
--- a/be/src/vec/columns/column_decimal.cpp
+++ b/be/src/vec/columns/column_decimal.cpp
@@ -117,15 +117,6 @@ void
ColumnDecimal<T>::deserialize_vec_with_null_map(std::vector<StringRef>& key
}
}
-template <typename T>
-UInt64 ColumnDecimal<T>::get64(size_t n) const {
- if constexpr (sizeof(T) > sizeof(UInt64)) {
- LOG(FATAL) << "Method get64 is not supported for " <<
get_family_name();
- } else {
- return static_cast<typename T::NativeType>(data[n]);
- }
-}
-
template <typename T>
void ColumnDecimal<T>::update_hash_with_value(size_t n, SipHash& hash) const {
hash.update(data[n]);
@@ -493,11 +484,6 @@ Decimal256
ColumnDecimal<Decimal256>::get_scale_multiplier() const {
return Decimal256(common::exp10_i256(scale));
}
-template <typename T>
-ColumnPtr ColumnDecimal<T>::index(const IColumn& indexes, size_t limit) const {
- return select_index_impl(*this, indexes, limit);
-}
-
template <typename T>
void ColumnDecimal<T>::replace_column_null_data(const uint8_t* __restrict
null_map) {
auto s = size();
diff --git a/be/src/vec/columns/column_decimal.h
b/be/src/vec/columns/column_decimal.h
index 7f286699ab8..705e29134c7 100644
--- a/be/src/vec/columns/column_decimal.h
+++ b/be/src/vec/columns/column_decimal.h
@@ -203,8 +203,6 @@ public:
void get(size_t n, Field& res) const override { res = (*this)[n]; }
bool get_bool(size_t n) const override { return bool(data[n]); }
Int64 get_int(size_t n) const override { return Int64(data[n].value *
scale); }
- UInt64 get64(size_t n) const override;
- bool is_default_at(size_t n) const override { return data[n].value == 0; }
void clear() override { data.clear(); }
@@ -213,17 +211,6 @@ public:
size_t filter(const IColumn::Filter& filter) override;
ColumnPtr permute(const IColumn::Permutation& perm, size_t limit) const
override;
- // ColumnPtr index(const IColumn & indexes, size_t limit) const
override;
-
- template <typename Type>
- ColumnPtr index_impl(const PaddedPODArray<Type>& indexes, size_t limit)
const;
-
- void get_indices_of_non_default_rows(IColumn::Offsets64& indices, size_t
from,
- size_t limit) const override {
- return this->template
get_indices_of_non_default_rows_impl<Self>(indices, from, limit);
- }
-
- ColumnPtr index(const IColumn& indexes, size_t limit) const override;
ColumnPtr replicate(const IColumn::Offsets& offsets) const override;
@@ -255,11 +242,6 @@ public:
data[self_row] = assert_cast<const Self&>(rhs).data[row];
}
- void replace_column_data_default(size_t self_row = 0) override {
- DCHECK(size() > self_row);
- data[self_row] = T();
- }
-
void replace_column_null_data(const uint8_t* __restrict null_map) override;
void sort_column(const ColumnSorter* sorter, EqualFlags& flags,
IColumn::Permutation& perms,
@@ -321,21 +303,4 @@ struct ColumnVectorOrDecimalT<T, true> {
template <typename T>
using ColumnVectorOrDecimal = typename ColumnVectorOrDecimalT<T,
IsDecimalNumber<T>>::Col;
-template <typename T>
-template <typename Type>
-ColumnPtr ColumnDecimal<T>::index_impl(const PaddedPODArray<Type>& indexes,
size_t limit) const {
- size_t size = indexes.size();
-
- if (limit == 0)
- limit = size;
- else
- limit = std::min(size, limit);
-
- auto res = this->create(limit, scale);
- typename Self::Container& res_data = res->get_data();
- for (size_t i = 0; i < limit; ++i) res_data[i] = data[indexes[i]];
-
- return res;
-}
-
} // namespace doris::vectorized
diff --git a/be/src/vec/columns/column_dictionary.h
b/be/src/vec/columns/column_dictionary.h
index 7bd0c27910d..b74457730c7 100644
--- a/be/src/vec/columns/column_dictionary.h
+++ b/be/src/vec/columns/column_dictionary.h
@@ -111,12 +111,6 @@ public:
size_t allocated_bytes() const override { return byte_size(); }
- void get_permutation(bool reverse, size_t limit, int nan_direction_hint,
- IColumn::Permutation& res) const override {
- LOG(FATAL) << "get_permutation not supported in ColumnDictionary";
- __builtin_unreachable();
- }
-
void reserve(size_t n) override { _codes.reserve(n); }
const char* get_family_name() const override { return "ColumnDictionary"; }
@@ -151,20 +145,8 @@ public:
__builtin_unreachable();
}
- [[noreturn]] int compare_at(size_t n, size_t m, const IColumn& rhs,
- int nan_direction_hint) const override {
- LOG(FATAL) << "compare_at not supported in ColumnDictionary";
- __builtin_unreachable();
- }
-
bool is_fixed_and_contiguous() const override { return true; }
- void get_indices_of_non_default_rows(IColumn::Offsets64& indices, size_t
from,
- size_t limit) const override {
- LOG(FATAL) << "get_indices_of_non_default_rows not supported in
ColumnDictionary";
- __builtin_unreachable();
- }
-
size_t size_of_value_if_fixed() const override { return sizeof(T); }
[[noreturn]] StringRef get_raw_data() const override {
@@ -210,11 +192,6 @@ public:
__builtin_unreachable();
}
- [[noreturn]] ColumnPtr index(const IColumn& indexes, size_t limit) const
override {
- LOG(FATAL) << "index not implemented";
- __builtin_unreachable();
- }
-
Status filter_by_selector(const uint16_t* sel, size_t sel_size, IColumn*
col_ptr) override {
auto* res_col = assert_cast<vectorized::ColumnString*>(col_ptr);
_strings.resize(sel_size);
@@ -236,11 +213,6 @@ public:
__builtin_unreachable();
}
- void replace_column_data_default(size_t self_row = 0) override {
- LOG(FATAL) << "should not call replace_column_data_default in
ColumnDictionary";
- __builtin_unreachable();
- }
-
/**
* Just insert dictionary data items, the items will append into _dict.
*/
diff --git a/be/src/vec/columns/column_dummy.h
b/be/src/vec/columns/column_dummy.h
index 403cd6228e1..3b7dd6c4dda 100644
--- a/be/src/vec/columns/column_dummy.h
+++ b/be/src/vec/columns/column_dummy.h
@@ -152,24 +152,6 @@ public:
__builtin_unreachable();
}
- void replace_column_data_default(size_t self_row = 0) override {
- LOG(FATAL) << "should not call the method in column dummy";
- __builtin_unreachable();
- }
-
- void get_indices_of_non_default_rows(Offsets64&, size_t, size_t) const
override {
- LOG(FATAL) << "should not call the method in column dummy";
- __builtin_unreachable();
- }
-
- ColumnPtr index(const IColumn& indexes, size_t limit) const override {
- if (indexes.size() < limit) {
- LOG(FATAL) << "Size of indexes is less than required.";
- __builtin_unreachable();
- }
- return clone_dummy(limit ? limit : s);
- }
-
protected:
size_t s;
};
diff --git a/be/src/vec/columns/column_filter_helper.cpp
b/be/src/vec/columns/column_filter_helper.cpp
index f65bd8d8649..8ef6a822640 100644
--- a/be/src/vec/columns/column_filter_helper.cpp
+++ b/be/src/vec/columns/column_filter_helper.cpp
@@ -33,11 +33,6 @@ void
ColumnFilterHelper::insert_value(doris::vectorized::UInt8 value) {
_null_map_column.get_data().push_back(0);
}
-void ColumnFilterHelper::insert_null() {
- _value_column.insert_default();
- _null_map_column.get_data().push_back(1);
-}
-
void ColumnFilterHelper::reserve(size_t size) {
_value_column.reserve(size);
_null_map_column.reserve(size);
diff --git a/be/src/vec/columns/column_filter_helper.h
b/be/src/vec/columns/column_filter_helper.h
index 2dc529ef3b4..ff1cb781a24 100644
--- a/be/src/vec/columns/column_filter_helper.h
+++ b/be/src/vec/columns/column_filter_helper.h
@@ -25,7 +25,6 @@ public:
ColumnFilterHelper(IColumn&);
void resize_fill(size_t size, UInt8 value);
- void insert_null();
void insert_value(UInt8 value);
void reserve(size_t size);
diff --git a/be/src/vec/columns/column_fixed_length_object.h
b/be/src/vec/columns/column_fixed_length_object.h
index 8bb9062b2f5..b83f11ff98a 100644
--- a/be/src/vec/columns/column_fixed_length_object.h
+++ b/be/src/vec/columns/column_fixed_length_object.h
@@ -25,6 +25,7 @@
#include "vec/columns/columns_common.h"
#include "vec/common/arena.h"
#include "vec/common/assert_cast.h"
+#include "vec/common/memcmp_small.h"
#include "vec/common/pod_array.h"
#include "vec/common/sip_hash.h"
@@ -57,7 +58,7 @@ public:
Container& get_data() { return _data; }
void resize(size_t n) override {
- DCHECK(_item_size > 0) << "_item_size should be greater than 0";
+ DCHECK_GT(_item_size, 0) << "_item_size should be greater than 0";
_data.resize(n * _item_size);
_item_count = n;
}
@@ -89,7 +90,7 @@ public:
if (_item_size == 0) {
_item_size = src_vec._item_size;
}
- DCHECK(_item_size == src_vec._item_size) << "dst and src should have
the same _item_size";
+ DCHECK_EQ(_item_size, src_vec._item_size) << "dst and src should have
the same _item_size";
resize(origin_size + new_size);
for (uint32_t i = 0; i < new_size; ++i) {
@@ -103,18 +104,21 @@ public:
_item_count = 0;
}
- [[noreturn]] Field operator[](size_t n) const override {
- LOG(FATAL) << "operator[] not supported";
- __builtin_unreachable();
+ Field operator[](size_t n) const override {
+ return {_data.data() + n * _item_size, _item_size};
}
- void get(size_t n, Field& res) const override { LOG(FATAL) << "get not
supported"; }
+ void get(size_t n, Field& res) const override {
+ res.assign_string(_data.data() + n * _item_size, _item_size);
+ }
StringRef get_data_at(size_t n) const override {
return {reinterpret_cast<const char*>(&_data[n * _item_size]),
_item_size};
}
- void insert(const Field& x) override { LOG(FATAL) << "insert not
supported"; }
+ void insert(const Field& x) override {
+ insert_data(vectorized::get<const String&>(x).data(), _item_size);
+ }
void insert_range_from(const IColumn& src, size_t start, size_t length)
override {
const auto& src_col = assert_cast<const ColumnFixedLengthObject&>(src);
@@ -142,9 +146,7 @@ public:
const auto& src_col = assert_cast<const ColumnFixedLengthObject&>(src);
DCHECK(_item_size == src_col._item_size) << "dst and src should have
the same _item_size "
<< _item_size << " " <<
src_col._item_size;
- size_t old_size = size();
- resize(old_size + 1);
- memcpy(&_data[old_size * _item_size], &src_col._data[n * _item_size],
_item_size);
+ insert_data((const char*)(&src_col._data[n * _item_size]), _item_size);
}
void insert_data(const char* pos, size_t length) override {
@@ -159,60 +161,68 @@ public:
memset(&_data[old_size * _item_size], 0, _item_size);
}
- void pop_back(size_t n) override { LOG(FATAL) << "pop_back not supported";
}
+ void pop_back(size_t n) override {
+ DCHECK_GE(_item_count, n);
+ resize(_item_count - n);
+ }
StringRef serialize_value_into_arena(size_t n, Arena& arena,
char const*& begin) const override {
- LOG(FATAL) << "serialize_value_into_arena not supported";
- __builtin_unreachable();
+ char* pos = arena.alloc_continue(_item_size, begin);
+ memcpy(pos, &_data[n * _item_size], _item_size);
+ return {pos, _item_size};
}
const char* deserialize_and_insert_from_arena(const char* pos) override {
- LOG(FATAL) << "deserialize_and_insert_from_arena not supported";
- __builtin_unreachable();
+ insert_data(pos, _item_size);
+ return pos + _item_size;
}
void update_hash_with_value(size_t n, SipHash& hash) const override {
hash.update(reinterpret_cast<const char*>(_data.data() + n *
_item_size), _item_size);
}
- [[noreturn]] ColumnPtr filter(const IColumn::Filter& filt,
- ssize_t result_size_hint) const override {
- LOG(FATAL) << "filter not supported";
- __builtin_unreachable();
- }
-
- [[noreturn]] size_t filter(const IColumn::Filter&) override {
- LOG(FATAL) << "filter not supported";
- __builtin_unreachable();
- }
-
- [[noreturn]] ColumnPtr permute(const IColumn::Permutation& perm, size_t
limit) const override {
- LOG(FATAL) << "permute not supported";
- __builtin_unreachable();
- }
+ ColumnPtr filter(const IColumn::Filter& filter, ssize_t result_size_hint)
const override {
+ column_match_filter_size(size(), filter.size());
+ auto res = create(_item_size);
+ res->resize(result_size_hint);
- [[noreturn]] int compare_at(size_t n, size_t m, const IColumn& rhs,
- int nan_direction_hint) const override {
- LOG(FATAL) << "compare_at not supported";
- __builtin_unreachable();
+ for (size_t i = 0, pos = 0; i < filter.size(); i++) {
+ if (filter[i]) {
+ memcpy(&res->_data[pos * _item_size], &_data[i * _item_size],
_item_size);
+ pos++;
+ }
+ }
+ return res;
}
- void get_permutation(bool reverse, size_t limit, int nan_direction_hint,
- IColumn::Permutation& res) const override {
- LOG(FATAL) << "get_permutation not supported";
- __builtin_unreachable();
+ size_t filter(const IColumn::Filter& filter) override {
+ size_t pos = 0;
+ for (size_t i = 0; i < filter.size(); i++) {
+ if (filter[i]) {
+ memcpy(&_data[pos * _item_size], &_data[i * _item_size],
_item_size);
+ pos++;
+ }
+ }
+ resize(pos);
+ return pos;
}
- ColumnPtr index(const IColumn& indexes, size_t limit) const override {
- LOG(FATAL) << "index not supported";
- __builtin_unreachable();
- }
+ ColumnPtr permute(const IColumn::Permutation& perm, size_t limit) const
override {
+ if (limit == 0) {
+ limit = size();
+ } else {
+ limit = std::min(size(), limit);
+ }
- void get_indices_of_non_default_rows(IColumn::Offsets64& indices, size_t
from,
- size_t limit) const override {
- LOG(FATAL) << "get_indices_of_non_default_rows not supported in
ColumnDictionary";
- __builtin_unreachable();
+ auto res = ColumnFixedLengthObject::create(_item_size);
+ res->resize(limit);
+ for (size_t i = 0; i < limit; ++i) {
+ memcpy_small_allow_read_write_overflow15(res->_data.data() + i *
_item_size,
+ _data.data() + perm[i] *
_item_size,
+ _item_size);
+ }
+ return res;
}
ColumnPtr replicate(const IColumn::Offsets& offsets) const override {
@@ -270,11 +280,6 @@ public:
memcpy(&_data[self_row * _item_size], obj.data, _item_size);
}
- void replace_column_data_default(size_t self_row = 0) override {
- LOG(FATAL) << "replace_column_data_default not supported";
- __builtin_unreachable();
- }
-
void insert_many_continuous_binary_data(const char* data, const uint32_t*
offsets,
const size_t num) override {
if (UNLIKELY(num == 0)) {
diff --git a/be/src/vec/columns/column_impl.h b/be/src/vec/columns/column_impl.h
index 4a66720c116..1c994592e73 100644
--- a/be/src/vec/columns/column_impl.h
+++ b/be/src/vec/columns/column_impl.h
@@ -53,45 +53,4 @@ void IColumn::append_data_by_selector_impl(MutablePtr& res,
const Selector& sele
append_data_by_selector_impl<Derived>(res, selector, 0, selector.size());
}
-template <typename Derived>
-void IColumn::get_indices_of_non_default_rows_impl(IColumn::Offsets64&
indices, size_t from,
- size_t limit) const {
- size_t to = limit && from + limit < size() ? from + limit : size();
- indices.reserve(indices.size() + to - from);
- for (size_t i = from; i < to; ++i) {
- if (!static_cast<const Derived&>(*this).is_default_at(i)) {
- indices.push_back(i);
- }
- }
-}
-
-template <typename Derived>
-double IColumn::get_ratio_of_default_rows_impl(double sample_ratio) const {
- if (sample_ratio <= 0.0 || sample_ratio > 1.0) {
- LOG(FATAL) << "Value of 'sample_ratio' must be in interval (0.0; 1.0],
but got: "
- << sample_ratio;
- }
- static constexpr auto max_number_of_rows_for_full_search = 1000;
- size_t num_rows = size();
- size_t num_sampled_rows = std::min(static_cast<size_t>(num_rows *
sample_ratio), num_rows);
- size_t num_checked_rows = 0;
- size_t res = 0;
- if (num_sampled_rows == num_rows || num_rows <=
max_number_of_rows_for_full_search) {
- for (size_t i = 0; i < num_rows; ++i)
- res += static_cast<const Derived&>(*this).is_default_at(i);
- num_checked_rows = num_rows;
- } else if (num_sampled_rows != 0) {
- for (size_t i = 0; i < num_rows; ++i) {
- if (num_checked_rows * num_rows <= i * num_sampled_rows) {
- res += static_cast<const Derived&>(*this).is_default_at(i);
- ++num_checked_rows;
- }
- }
- }
- if (num_checked_rows == 0) {
- return 0.0;
- }
- return static_cast<double>(res) / num_checked_rows;
-}
-
} // namespace doris::vectorized
diff --git a/be/src/vec/columns/column_map.h b/be/src/vec/columns/column_map.h
index d0cd9e588a2..73e367d0462 100644
--- a/be/src/vec/columns/column_map.h
+++ b/be/src/vec/columns/column_map.h
@@ -123,12 +123,6 @@ public:
int compare_at(size_t n, size_t m, const IColumn& rhs_, int
nan_direction_hint) const override;
- void get_permutation(bool reverse, size_t limit, int nan_direction_hint,
- Permutation& res) const override {
- LOG(FATAL) << "get_permutation not implemented";
- __builtin_unreachable();
- }
-
void insert_indices_from(const IColumn& src, const uint32_t* indices_begin,
const uint32_t* indices_end) override;
@@ -145,10 +139,6 @@ public:
LOG(FATAL) << "Method replace_column_data is not supported for " <<
get_name();
}
- void replace_column_data_default(size_t self_row = 0) override {
- LOG(FATAL) << "Method replace_column_data_default is not supported for
" << get_name();
- }
-
ColumnArray::Offsets64& ALWAYS_INLINE get_offsets() {
return assert_cast<COffsets&>(*offsets_column).get_data();
}
diff --git a/be/src/vec/columns/column_nullable.cpp
b/be/src/vec/columns/column_nullable.cpp
index fea85917d72..6efa690d7db 100644
--- a/be/src/vec/columns/column_nullable.cpp
+++ b/be/src/vec/columns/column_nullable.cpp
@@ -652,12 +652,6 @@ ColumnPtr remove_nullable(const ColumnPtr& column) {
return column;
}
-ColumnPtr ColumnNullable::index(const IColumn& indexes, size_t limit) const {
- ColumnPtr indexed_data = get_nested_column().index(indexes, limit);
- ColumnPtr indexed_null_map = get_null_map_column().index(indexes, limit);
- return ColumnNullable::create(indexed_data, indexed_null_map);
-}
-
void check_set_nullable(ColumnPtr& argument_column,
ColumnVector<UInt8>::MutablePtr& null_map,
bool is_single) {
if (const auto* nullable =
check_and_get_column<ColumnNullable>(*argument_column)) {
diff --git a/be/src/vec/columns/column_nullable.h
b/be/src/vec/columns/column_nullable.h
index d55bcd0bcf6..ffa32a96860 100644
--- a/be/src/vec/columns/column_nullable.h
+++ b/be/src/vec/columns/column_nullable.h
@@ -92,7 +92,6 @@ public:
PURE bool is_null_at(size_t n) const override {
return assert_cast<const ColumnUInt8&>(*null_map).get_data()[n] != 0;
}
- bool is_default_at(size_t n) const override { return is_null_at(n); }
Field operator[](size_t n) const override;
void get(size_t n, Field& res) const override;
bool get_bool(size_t n) const override {
@@ -103,8 +102,6 @@ public:
return is_null_at(n) ? false
: assert_cast<const
ColumnUInt8*>(nested_column.get())->get_bool(n);
}
- UInt64 get64(size_t n) const override { return nested_column->get64(n); }
- Float64 get_float64(size_t n) const override { return
nested_column->get_float64(n); }
StringRef get_data_at(size_t n) const override;
/// Will insert null value if pos=nullptr
@@ -276,7 +273,6 @@ public:
bool is_column_map() const override { return
get_nested_column().is_column_map(); }
bool is_column_struct() const override { return
get_nested_column().is_column_struct(); }
bool is_fixed_and_contiguous() const override { return false; }
- bool values_have_fixed_size() const override { return
nested_column->values_have_fixed_size(); }
bool is_exclusive() const override {
return IColumn::is_exclusive() && nested_column->is_exclusive() &&
null_map->is_exclusive();
@@ -353,23 +349,41 @@ public:
if (!nullable_rhs.is_null_at(row)) {
nested_column->replace_column_data(*nullable_rhs.nested_column,
row, self_row);
- } else {
- nested_column->replace_column_data_default(self_row);
}
}
- void replace_column_data_default(size_t self_row = 0) override {
- LOG(FATAL) << "should not call the method in column nullable";
- __builtin_unreachable();
- }
-
MutableColumnPtr convert_to_predicate_column_if_dictionary() override {
nested_column =
get_nested_column().convert_to_predicate_column_if_dictionary();
return get_ptr();
}
double get_ratio_of_default_rows(double sample_ratio) const override {
- return get_ratio_of_default_rows_impl<ColumnNullable>(sample_ratio);
+ if (sample_ratio <= 0.0 || sample_ratio > 1.0) {
+ throw doris::Exception(ErrorCode::INTERNAL_ERROR, "invalid
sample_ratio {}",
+ sample_ratio);
+ }
+ static constexpr auto MAX_NUMBER_OF_ROWS_FOR_FULL_SEARCH = 1000;
+ size_t num_rows = size();
+ size_t num_sampled_rows = std::min(static_cast<size_t>(num_rows *
sample_ratio), num_rows);
+ size_t num_checked_rows = 0;
+ size_t res = 0;
+ if (num_sampled_rows == num_rows || num_rows <=
MAX_NUMBER_OF_ROWS_FOR_FULL_SEARCH) {
+ for (size_t i = 0; i < num_rows; ++i) {
+ res += is_null_at(i);
+ }
+ num_checked_rows = num_rows;
+ } else if (num_sampled_rows != 0) {
+ for (size_t i = 0; i < num_rows; ++i) {
+ if (num_checked_rows * num_rows <= i * num_sampled_rows) {
+ res += is_null_at(i);
+ ++num_checked_rows;
+ }
+ }
+ }
+ if (num_checked_rows == 0) {
+ return 0.0;
+ }
+ return static_cast<double>(res) / num_checked_rows;
}
void convert_dict_codes_if_necessary() override {
@@ -390,12 +404,6 @@ public:
std::pair<RowsetId, uint32_t> get_rowset_segment_id() const override {
return nested_column->get_rowset_segment_id();
}
- void get_indices_of_non_default_rows(Offsets64& indices, size_t from,
- size_t limit) const override {
- get_indices_of_non_default_rows_impl<ColumnNullable>(indices, from,
limit);
- }
-
- ColumnPtr index(const IColumn& indexes, size_t limit) const override;
private:
// the two functions will not update `_need_update_has_null`
diff --git a/be/src/vec/columns/column_object.cpp
b/be/src/vec/columns/column_object.cpp
index 3bae978f4d3..36a267bc0d8 100644
--- a/be/src/vec/columns/column_object.cpp
+++ b/be/src/vec/columns/column_object.cpp
@@ -512,10 +512,6 @@ MutableColumnPtr ColumnObject::apply_for_subcolumns(Func&&
func) const {
}
return res;
}
-ColumnPtr ColumnObject::index(const IColumn& indexes, size_t limit) const {
- return apply_for_subcolumns(
- [&](const auto& subcolumn) { return subcolumn.index(indexes,
limit); });
-}
bool ColumnObject::Subcolumn::check_if_sparse_column(size_t num_rows) {
if (num_rows < config::variant_threshold_rows_to_estimate_sparse_column) {
@@ -1017,7 +1013,7 @@ void ColumnObject::Subcolumn::wrapp_array_nullable() {
auto new_null_map = ColumnUInt8::create();
new_null_map->reserve(result_column->size());
auto& null_map_data = new_null_map->get_data();
- auto array = static_cast<const ColumnArray*>(result_column.get());
+ const auto* array = static_cast<const
ColumnArray*>(result_column.get());
for (size_t i = 0; i < array->size(); ++i) {
null_map_data.push_back(array->is_default_at(i));
}
@@ -1603,8 +1599,4 @@ void ColumnObject::replace_column_data(const IColumn&
col, size_t row, size_t se
LOG(FATAL) << "Method replace_column_data is not supported for " <<
get_name();
}
-void ColumnObject::replace_column_data_default(size_t self_row) {
- LOG(FATAL) << "Method replace_column_data_default is not supported for "
<< get_name();
-}
-
} // namespace doris::vectorized
diff --git a/be/src/vec/columns/column_object.h
b/be/src/vec/columns/column_object.h
index 55abd534dd1..5f2cf129b99 100644
--- a/be/src/vec/columns/column_object.h
+++ b/be/src/vec/columns/column_object.h
@@ -474,33 +474,13 @@ public:
ColumnPtr permute(const Permutation&, size_t) const override;
- int compare_at(size_t n, size_t m, const IColumn& rhs, int
nan_direction_hint) const override {
- LOG(FATAL) << "should not call the method in column object";
- return 0;
- }
-
- void get_permutation(bool reverse, size_t limit, int nan_direction_hint,
- Permutation& res) const override {
- LOG(FATAL) << "should not call the method in column object";
- __builtin_unreachable();
- }
-
bool is_variable_length() const override { return true; }
void replace_column_data(const IColumn&, size_t row, size_t self_row)
override;
- void replace_column_data_default(size_t self_row) override;
-
- void get_indices_of_non_default_rows(Offsets64&, size_t, size_t) const
override {
- LOG(FATAL) << "should not call the method in column object";
- __builtin_unreachable();
- }
-
template <typename Func>
MutableColumnPtr apply_for_subcolumns(Func&& func) const;
- ColumnPtr index(const IColumn& indexes, size_t limit) const override;
-
// Extract path from root column and replace root with new extracted
column,
// root must be jsonb type
Status extract_root(const PathInData& path);
diff --git a/be/src/vec/columns/column_string.cpp
b/be/src/vec/columns/column_string.cpp
index 514980cc8ba..c737cd5dd5d 100644
--- a/be/src/vec/columns/column_string.cpp
+++ b/be/src/vec/columns/column_string.cpp
@@ -432,44 +432,6 @@ void
ColumnStr<T>::deserialize_vec_with_null_map(std::vector<StringRef>& keys,
}
}
-template <typename T>
-template <typename Type>
-ColumnPtr ColumnStr<T>::index_impl(const PaddedPODArray<Type>& indexes, size_t
limit) const {
- if (limit == 0) {
- return ColumnStr<T>::create();
- }
-
- auto res = ColumnStr<T>::create();
-
- Chars& res_chars = res->chars;
- auto& res_offsets = res->offsets;
-
- size_t new_chars_size = 0;
- for (size_t i = 0; i < limit; ++i) {
- new_chars_size += size_at(indexes[i]);
- }
- check_chars_length(new_chars_size, limit);
- res_chars.resize(new_chars_size);
-
- res_offsets.resize(limit);
-
- T current_new_offset = 0;
-
- for (size_t i = 0; i < limit; ++i) {
- size_t j = indexes[i];
- size_t string_offset = offsets[j - 1];
- size_t string_size = offsets[j] - string_offset;
-
-
memcpy_small_allow_read_write_overflow15(&res_chars[current_new_offset],
- &chars[string_offset],
string_size);
-
- current_new_offset += string_size;
- res_offsets[i] = current_new_offset;
- }
-
- return res;
-}
-
template <typename T>
template <bool positive>
struct ColumnStr<T>::less {
@@ -601,11 +563,6 @@ void ColumnStr<T>::compare_internal(size_t rhs_row_id,
const IColumn& rhs, int n
}
}
-template <typename T>
-ColumnPtr ColumnStr<T>::index(const IColumn& indexes, size_t limit) const {
- return select_index_impl(*this, indexes, limit);
-}
-
template <typename T>
ColumnPtr ColumnStr<T>::convert_column_if_overflow() {
if (std::is_same_v<T, UInt32> && chars.size() >
config::string_overflow_size) {
diff --git a/be/src/vec/columns/column_string.h
b/be/src/vec/columns/column_string.h
index 81a6a469b5b..d0994607a46 100644
--- a/be/src/vec/columns/column_string.h
+++ b/be/src/vec/columns/column_string.h
@@ -492,11 +492,6 @@ public:
void sort_column(const ColumnSorter* sorter, EqualFlags& flags,
IColumn::Permutation& perms,
EqualRange& range, bool last_column) const override;
- // ColumnPtr index(const IColumn & indexes, size_t limit) const
override;
-
- template <typename Type>
- ColumnPtr index_impl(const PaddedPODArray<Type>& indexes, size_t limit)
const;
-
void insert_default() override { offsets.push_back(chars.size()); }
void insert_many_defaults(size_t length) override {
@@ -551,12 +546,6 @@ public:
__builtin_unreachable();
}
- // should replace according to 0,1,2... ,size,0,1,2...
- void replace_column_data_default(size_t self_row = 0) override {
- LOG(FATAL) << "Method replace_column_data_default is not supported for
ColumnString";
- __builtin_unreachable();
- }
-
void compare_internal(size_t rhs_row_id, const IColumn& rhs, int
nan_direction_hint,
int direction, std::vector<uint8>& cmp_res,
uint8* __restrict filter) const override;
@@ -570,18 +559,6 @@ public:
return shrinked_column;
}
- void get_indices_of_non_default_rows(IColumn::Offsets64& indices, size_t
from,
- size_t limit) const override {
- return this->template
get_indices_of_non_default_rows_impl<ColumnStr<T>>(indices, from,
-
limit);
- }
-
- ColumnPtr index(const IColumn& indexes, size_t limit) const override;
-
- double get_ratio_of_default_rows(double sample_ratio) const override {
- return this->template
get_ratio_of_default_rows_impl<ColumnStr<T>>(sample_ratio);
- }
-
ColumnPtr convert_column_if_overflow() override;
};
diff --git a/be/src/vec/columns/column_struct.cpp
b/be/src/vec/columns/column_struct.cpp
index 7b25d9a912c..86503601942 100644
--- a/be/src/vec/columns/column_struct.cpp
+++ b/be/src/vec/columns/column_struct.cpp
@@ -120,16 +120,6 @@ void ColumnStruct::get(size_t n, Field& res) const {
}
}
-bool ColumnStruct::is_default_at(size_t n) const {
- const size_t tuple_size = columns.size();
- for (size_t i = 0; i < tuple_size; ++i) {
- if (!columns[i]->is_default_at(n)) {
- return false;
- }
- }
- return true;
-}
-
void ColumnStruct::insert(const Field& x) {
const auto& tuple = x.get<const Tuple&>();
const size_t tuple_size = columns.size();
diff --git a/be/src/vec/columns/column_struct.h
b/be/src/vec/columns/column_struct.h
index b80c833edf7..8001b721fcb 100644
--- a/be/src/vec/columns/column_struct.h
+++ b/be/src/vec/columns/column_struct.h
@@ -93,7 +93,6 @@ public:
Field operator[](size_t n) const override;
void get(size_t n, Field& res) const override;
- bool is_default_at(size_t n) const override;
[[noreturn]] StringRef get_data_at(size_t n) const override {
LOG(FATAL) << "Method get_data_at is not supported for " + get_name();
__builtin_unreachable();
@@ -125,11 +124,6 @@ public:
void insert_indices_from(const IColumn& src, const uint32_t* indices_begin,
const uint32_t* indices_end) override;
- void get_permutation(bool reverse, size_t limit, int nan_direction_hint,
- Permutation& res) const override {
- LOG(FATAL) << "get_permutation not implemented";
- __builtin_unreachable();
- }
void append_data_by_selector(MutableColumnPtr& res, const Selector&
selector) const override {
return append_data_by_selector_impl<ColumnStruct>(res, selector);
}
@@ -141,10 +135,6 @@ public:
LOG(FATAL) << "Method replace_column_data is not supported for " <<
get_name();
}
- void replace_column_data_default(size_t self_row = 0) override {
- LOG(FATAL) << "Method replace_column_data_default is not supported for
" << get_name();
- }
-
void insert_range_from(const IColumn& src, size_t start, size_t length)
override;
void insert_range_from_ignore_overflow(const IColumn& src, size_t start,
size_t length) override;
@@ -153,7 +143,6 @@ public:
ColumnPtr permute(const Permutation& perm, size_t limit) const override;
ColumnPtr replicate(const Offsets& offsets) const override;
- // ColumnPtr index(const IColumn & indexes, size_t limit) const override;
int compare_at(size_t n, size_t m, const IColumn& rhs_, int
nan_direction_hint) const override;
MutableColumnPtr get_shrinked_column() override;
diff --git a/be/src/vec/columns/column_vector.cpp
b/be/src/vec/columns/column_vector.cpp
index 5ad9fa7e632..60a75420405 100644
--- a/be/src/vec/columns/column_vector.cpp
+++ b/be/src/vec/columns/column_vector.cpp
@@ -334,16 +334,6 @@ MutableColumnPtr ColumnVector<T>::clone_resized(size_t
size) const {
return res;
}
-template <typename T>
-UInt64 ColumnVector<T>::get64(size_t n) const {
- return static_cast<UInt64>(data[n]);
-}
-
-template <typename T>
-Float64 ColumnVector<T>::get_float64(size_t n) const {
- return static_cast<Float64>(data[n]);
-}
-
template <typename T>
void ColumnVector<T>::insert_range_from(const IColumn& src, size_t start,
size_t length) {
const ColumnVector& src_vec = assert_cast<const ColumnVector&>(src);
@@ -536,11 +526,6 @@ ColumnPtr ColumnVector<T>::replicate(const
IColumn::Offsets& offsets) const {
return res;
}
-template <typename T>
-ColumnPtr ColumnVector<T>::index(const IColumn& indexes, size_t limit) const {
- return select_index_impl(*this, indexes, limit);
-}
-
template <typename T>
void ColumnVector<T>::replace_column_null_data(const uint8_t* __restrict
null_map) {
auto s = size();
diff --git a/be/src/vec/columns/column_vector.h
b/be/src/vec/columns/column_vector.h
index a43e17f88bf..af87c270ba6 100644
--- a/be/src/vec/columns/column_vector.h
+++ b/be/src/vec/columns/column_vector.h
@@ -341,14 +341,8 @@ public:
void get(size_t n, Field& res) const override { res = (*this)[n]; }
- UInt64 get64(size_t n) const override;
-
- Float64 get_float64(size_t n) const override;
-
void clear() override { data.clear(); }
- UInt64 get_uint(size_t n) const override { return UInt64(data[n]); }
-
bool get_bool(size_t n) const override { return bool(data[n]); }
Int64 get_int(size_t n) const override { return Int64(data[n]); }
@@ -373,13 +367,6 @@ public:
ColumnPtr permute(const IColumn::Permutation& perm, size_t limit) const
override;
- template <typename Type>
- ColumnPtr index_impl(const PaddedPODArray<Type>& indexes, size_t limit)
const;
-
- double get_ratio_of_default_rows(double sample_ratio) const override {
- return this->template
get_ratio_of_default_rows_impl<Self>(sample_ratio);
- }
-
ColumnPtr replicate(const IColumn::Offsets& offsets) const override;
void append_data_by_selector(MutableColumnPtr& res,
@@ -415,11 +402,6 @@ public:
data[self_row] = assert_cast<const Self&>(rhs).data[row];
}
- void replace_column_data_default(size_t self_row = 0) override {
- DCHECK(size() > self_row);
- data[self_row] = T();
- }
-
void replace_column_null_data(const uint8_t* __restrict null_map) override;
void sort_column(const ColumnSorter* sorter, EqualFlags& flags,
IColumn::Permutation& perms,
@@ -428,32 +410,9 @@ public:
void compare_internal(size_t rhs_row_id, const IColumn& rhs, int
nan_direction_hint,
int direction, std::vector<uint8>& cmp_res,
uint8* __restrict filter) const override;
- void get_indices_of_non_default_rows(IColumn::Offsets64& indices, size_t
from,
- size_t limit) const override {
- return this->template
get_indices_of_non_default_rows_impl<Self>(indices, from, limit);
- }
-
- ColumnPtr index(const IColumn& indexes, size_t limit) const override;
protected:
Container data;
};
-template <typename T>
-template <typename Type>
-ColumnPtr ColumnVector<T>::index_impl(const PaddedPODArray<Type>& indexes,
size_t limit) const {
- size_t size = indexes.size();
-
- if (limit == 0)
- limit = size;
- else
- limit = std::min(size, limit);
-
- auto res = this->create(limit);
- typename Self::Container& res_data = res->get_data();
- for (size_t i = 0; i < limit; ++i) res_data[i] = data[indexes[i]];
-
- return res;
-}
-
} // namespace doris::vectorized
diff --git a/be/src/vec/columns/columns_common.cpp
b/be/src/vec/columns/columns_common.cpp
index 4888db34154..d1f7df85433 100644
--- a/be/src/vec/columns/columns_common.cpp
+++ b/be/src/vec/columns/columns_common.cpp
@@ -88,18 +88,6 @@ std::vector<size_t>
count_columns_size_in_selector(IColumn::ColumnIndex num_colu
return counts;
}
-bool memory_is_byte(const void* data, size_t size, uint8_t byte) {
- if (size == 0) {
- return true;
- }
- auto ptr = reinterpret_cast<const uint8_t*>(data);
- return *ptr == byte && memcmp(ptr, ptr + 1, size - 1) == 0;
-}
-
-bool memory_is_zero(const void* data, size_t size) {
- return memory_is_byte(data, size, 0x0);
-}
-
namespace {
/// Implementation details of filterArraysImpl function, used as template
parameter.
/// Allow to build or not to build offsets array.
@@ -391,21 +379,4 @@ INSTANTIATE(Float64, ColumnArray::Offset64)
#undef INSTANTIATE
-namespace detail {
-template <typename T>
-const PaddedPODArray<T>* get_indexes_data(const IColumn& indexes) {
- auto* column = typeid_cast<const ColumnVector<T>*>(&indexes);
- if (column) {
- return &column->get_data();
- }
-
- return nullptr;
-}
-
-template const PaddedPODArray<UInt8>* get_indexes_data<UInt8>(const IColumn&
indexes);
-template const PaddedPODArray<UInt16>* get_indexes_data<UInt16>(const IColumn&
indexes);
-template const PaddedPODArray<UInt32>* get_indexes_data<UInt32>(const IColumn&
indexes);
-template const PaddedPODArray<UInt64>* get_indexes_data<UInt64>(const IColumn&
indexes);
-} // namespace detail
-
} // namespace doris::vectorized
diff --git a/be/src/vec/columns/columns_common.h
b/be/src/vec/columns/columns_common.h
index ac2b15743e8..39bf0e83211 100644
--- a/be/src/vec/columns/columns_common.h
+++ b/be/src/vec/columns/columns_common.h
@@ -47,10 +47,6 @@ size_t count_bytes_in_filter(const IColumn::Filter& filt);
std::vector<size_t> count_columns_size_in_selector(IColumn::ColumnIndex
num_columns,
const IColumn::Selector&
selector);
-/// Returns true, if the memory contains only zeros.
-bool memory_is_zero(const void* data, size_t size);
-bool memory_is_byte(const void* data, size_t size, uint8_t byte);
-
/// The general implementation of `filter` function for ColumnArray and
ColumnString.
template <typename T, typename OT>
void filter_arrays_impl(const PaddedPODArray<T>& src_elems, const
PaddedPODArray<OT>& src_offsets,
@@ -90,46 +86,4 @@ inline void column_match_filter_size(size_t size, size_t
filter_size) {
}
}
-namespace detail {
-template <typename T>
-const PaddedPODArray<T>* get_indexes_data(const IColumn& indexes);
-}
-
-/// Check limit <= indexes->size() and call column.index_impl(const
PaddedPodArray<Type> & indexes, UInt64 limit).
-template <typename Column>
-ColumnPtr select_index_impl(const Column& column, const IColumn& indexes,
size_t limit) {
- if (limit == 0) {
- limit = indexes.size();
- }
-
- if (indexes.size() < limit) {
- LOG(FATAL) << "Size of indexes is less than required.";
- __builtin_unreachable();
- }
-
- if (auto* data_uint8 = detail::get_indexes_data<UInt8>(indexes)) {
- return column.template index_impl<UInt8>(*data_uint8, limit);
- } else if (auto* data_uint16 = detail::get_indexes_data<UInt16>(indexes)) {
- return column.template index_impl<UInt16>(*data_uint16, limit);
- } else if (auto* data_uint32 = detail::get_indexes_data<UInt32>(indexes)) {
- return column.template index_impl<UInt32>(*data_uint32, limit);
- } else if (auto* data_uint64 = detail::get_indexes_data<UInt64>(indexes)) {
- return column.template index_impl<UInt64>(*data_uint64, limit);
- } else {
- LOG(FATAL) << "Indexes column for IColumn::select must be ColumnUInt,
got"
- << indexes.get_name();
- return nullptr;
- }
-}
-
-#define INSTANTIATE_INDEX_IMPL(Column)
\
- template ColumnPtr Column::index_impl<UInt8>(const PaddedPODArray<UInt8>&
indexes, \
- size_t limit) const;
\
- template ColumnPtr Column::index_impl<UInt16>(const
PaddedPODArray<UInt16>& indexes, \
- size_t limit) const;
\
- template ColumnPtr Column::index_impl<UInt32>(const
PaddedPODArray<UInt32>& indexes, \
- size_t limit) const;
\
- template ColumnPtr Column::index_impl<UInt64>(const
PaddedPODArray<UInt64>& indexes, \
- size_t limit) const;
-
} // namespace doris::vectorized
diff --git a/be/src/vec/columns/predicate_column.h
b/be/src/vec/columns/predicate_column.h
index 322226c8225..c1101038870 100644
--- a/be/src/vec/columns/predicate_column.h
+++ b/be/src/vec/columns/predicate_column.h
@@ -145,17 +145,6 @@ public:
__builtin_unreachable();
}
- void get_indices_of_non_default_rows(IColumn::Offsets64& indices, size_t
from,
- size_t limit) const override {
- LOG(FATAL) << "get_indices_of_non_default_rows not supported in
PredicateColumnType";
- __builtin_unreachable();
- }
-
- [[noreturn]] ColumnPtr index(const IColumn& indexes, size_t limit) const
override {
- LOG(FATAL) << "index not supported in PredicateColumnType";
- __builtin_unreachable();
- }
-
void insert_string_value(const char* data_ptr, size_t length) {
StringRef sv((char*)data_ptr, length);
data.push_back_without_reserve(sv);
@@ -329,12 +318,6 @@ public:
size_t allocated_bytes() const override { return byte_size(); }
- void get_permutation(bool reverse, size_t limit, int nan_direction_hint,
- IColumn::Permutation& res) const override {
- LOG(FATAL) << "get_permutation not supported in PredicateColumnType";
- __builtin_unreachable();
- }
-
void reserve(size_t n) override { data.reserve(n); }
const char* get_family_name() const override { return TypeName<T>::get(); }
@@ -359,21 +342,6 @@ public:
__builtin_unreachable();
}
- [[noreturn]] UInt64 get64(size_t n) const override {
- LOG(FATAL) << "get field not supported in PredicateColumnTyped";
- __builtin_unreachable();
- }
-
- [[noreturn]] Float64 get_float64(size_t n) const override {
- LOG(FATAL) << "get field not supported in PredicateColumnType";
- __builtin_unreachable();
- }
-
- [[noreturn]] UInt64 get_uint(size_t n) const override {
- LOG(FATAL) << "get field not supported in PredicateColumnType";
- __builtin_unreachable();
- }
-
[[noreturn]] bool get_bool(size_t n) const override {
LOG(FATAL) << "get field not supported in PredicateColumnType";
__builtin_unreachable();
@@ -396,12 +364,6 @@ public:
__builtin_unreachable();
}
- [[noreturn]] int compare_at(size_t n, size_t m, const IColumn& rhs,
- int nan_direction_hint) const override {
- LOG(FATAL) << "compare_at not supported in PredicateColumnType";
- __builtin_unreachable();
- }
-
bool is_fixed_and_contiguous() const override { return true; }
size_t size_of_value_if_fixed() const override { return sizeof(T); }
@@ -468,11 +430,6 @@ public:
__builtin_unreachable();
}
- void replace_column_data_default(size_t self_row = 0) override {
- LOG(FATAL) << "should not call replace_column_data_default in
predicate column";
- __builtin_unreachable();
- }
-
private:
Container data;
// manages the memory for slice's data(For string type)
diff --git a/be/src/vec/core/block.cpp b/be/src/vec/core/block.cpp
index f439ddc4c32..066ebd6ed1e 100644
--- a/be/src/vec/core/block.cpp
+++ b/be/src/vec/core/block.cpp
@@ -758,7 +758,6 @@ void Block::filter_block_internal(Block* block, const
std::vector<uint32_t>& col
"filter_size={}",
result_size, count);
}
- CHECK_EQ(result_size, count);
} else {
column = column->filter(filter, count);
}
diff --git a/be/src/vec/data_types/serde/data_type_time_serde.cpp
b/be/src/vec/data_types/serde/data_type_time_serde.cpp
index 177cf08f1f4..74b1dc49deb 100644
--- a/be/src/vec/data_types/serde/data_type_time_serde.cpp
+++ b/be/src/vec/data_types/serde/data_type_time_serde.cpp
@@ -23,7 +23,7 @@ template <bool is_binary_format>
Status DataTypeTimeSerDe::_write_column_to_mysql(const IColumn& column,
MysqlRowBuffer<is_binary_format>& result,
int row_idx, bool col_const)
const {
- auto& data = assert_cast<const ColumnVector<Float64>&>(column).get_data();
+ auto& data = assert_cast<const ColumnFloat64&>(column).get_data();
const auto col_index = index_check_const(row_idx, col_const);
if (UNLIKELY(0 != result.push_time(data[col_index]))) {
return Status::InternalError("pack mysql buffer failed.");
@@ -57,7 +57,7 @@ template <bool is_binary_format>
Status DataTypeTimeV2SerDe::_write_column_to_mysql(const IColumn& column,
MysqlRowBuffer<is_binary_format>& result,
int row_idx, bool
col_const) const {
- auto& data = assert_cast<const ColumnVector<Float64>&>(column).get_data();
+ auto& data = assert_cast<const ColumnFloat64&>(column).get_data();
const auto col_index = index_check_const(row_idx, col_const);
// _nesting_level >= 2 means this time is in complex type
// and we should add double quotes
diff --git a/be/src/vec/functions/array/function_array_distance.h
b/be/src/vec/functions/array/function_array_distance.h
index fac25e1cb88..e0084ba794f 100644
--- a/be/src/vec/functions/array/function_array_distance.h
+++ b/be/src/vec/functions/array/function_array_distance.h
@@ -19,6 +19,8 @@
#include "vec/columns/column.h"
#include "vec/columns/column_array.h"
+#include "vec/columns/columns_number.h"
+#include "vec/common/assert_cast.h"
#include "vec/core/types.h"
#include "vec/data_types/data_type.h"
#include "vec/data_types/data_type_array.h"
@@ -119,15 +121,15 @@ public:
}
// prepare return data
- auto dst = ColumnVector<Float64>::create(input_rows_count);
+ auto dst = ColumnFloat64::create(input_rows_count);
auto& dst_data = dst->get_data();
auto dst_null_column = ColumnUInt8::create(input_rows_count);
auto& dst_null_data = dst_null_column->get_data();
const auto& offsets1 = *arr1.offsets_ptr;
const auto& offsets2 = *arr2.offsets_ptr;
- const auto& nested_col1 = arr1.nested_col;
- const auto& nested_col2 = arr2.nested_col;
+ const auto& nested_col1 = assert_cast<const
ColumnFloat64*>(arr1.nested_col);
+ const auto& nested_col2 = assert_cast<const
ColumnFloat64*>(arr2.nested_col);
for (ssize_t row = 0; row < offsets1.size(); ++row) {
if (arr1.array_nullmap_data && arr1.array_nullmap_data[row]) {
dst_null_data[row] = true;
@@ -156,8 +158,8 @@ public:
dst_null_data[row] = true;
break;
}
- DistanceImpl::accumulate(st, nested_col1->get_float64(pos),
- nested_col2->get_float64(pos));
+ DistanceImpl::accumulate(st, nested_col1->get_element(pos),
+ nested_col2->get_element(pos));
}
if (!dst_null_data[row]) {
dst_data[row] = DistanceImpl::finalize(st);
@@ -178,10 +180,7 @@ private:
}
auto nested_type =
remove_nullable(assert_cast<const
DataTypeArray&>(*array_type).get_nested_type());
- if (is_integer(nested_type) || is_float(nested_type)) {
- return true;
- }
- return false;
+ return is_integer(nested_type) || is_float(nested_type);
}
};
diff --git a/be/src/vec/functions/array/function_array_first_or_last_index.cpp
b/be/src/vec/functions/array/function_array_first_or_last_index.cpp
index 3d1e88c49fc..144c7a9194f 100644
--- a/be/src/vec/functions/array/function_array_first_or_last_index.cpp
+++ b/be/src/vec/functions/array/function_array_first_or_last_index.cpp
@@ -73,15 +73,15 @@ public:
const ColumnArray* array_column = nullptr;
const UInt8* array_null_map = nullptr;
if (src_column->is_nullable()) {
- auto nullable_array = assert_cast<const
ColumnNullable*>(src_column.get());
+ const auto* nullable_array = assert_cast<const
ColumnNullable*>(src_column.get());
array_column = assert_cast<const
ColumnArray*>(&nullable_array->get_nested_column());
array_null_map =
nullable_array->get_null_map_column().get_data().data();
} else {
array_column = assert_cast<const ColumnArray*>(src_column.get());
}
- auto& src_nested_data = array_column->get_data();
- auto& src_offset = array_column->get_offsets();
+ const auto& src_nested_data = array_column->get_data();
+ const auto& src_offset = array_column->get_offsets();
auto result_data_col = ColumnInt64::create(input_rows_count, 0);
auto& result_data = result_data_col->get_data();
diff --git a/be/src/vec/functions/array/function_array_shuffle.cpp
b/be/src/vec/functions/array/function_array_shuffle.cpp
index cb3fc8ab7ee..8d46aaa6933 100644
--- a/be/src/vec/functions/array/function_array_shuffle.cpp
+++ b/be/src/vec/functions/array/function_array_shuffle.cpp
@@ -30,6 +30,7 @@
#include "vec/aggregate_functions/aggregate_function.h"
#include "vec/columns/column.h"
#include "vec/columns/column_array.h"
+#include "vec/columns/columns_number.h"
#include "vec/common/assert_cast.h"
#include "vec/core/block.h"
#include "vec/core/column_numbers.h"
@@ -74,7 +75,7 @@ public:
if (arguments.size() == 2) {
ColumnPtr seed_column =
block.get_by_position(arguments[1]).column->convert_to_full_column_if_const();
- seed = seed_column->get_uint(0);
+ seed = assert_cast<const
ColumnInt64*>(seed_column.get())->get_element(0);
}
std::mt19937 g(seed);
diff --git a/be/src/vec/functions/function_case.h
b/be/src/vec/functions/function_case.h
index 26e12e7bd13..f320ab046c7 100644
--- a/be/src/vec/functions/function_case.h
+++ b/be/src/vec/functions/function_case.h
@@ -93,8 +93,8 @@ struct CaseWhenColumnHolder {
pair_count = (end - begin) / 2 + 1; // when/then at [1: pair_count)
for (int i = begin; i < end; i += 2) {
-
when_ptrs.emplace_back(OptionalPtr(block.get_by_position(arguments[i]).column));
-
then_ptrs.emplace_back(OptionalPtr(block.get_by_position(arguments[i +
1]).column));
+ when_ptrs.emplace_back(block.get_by_position(arguments[i]).column);
+ then_ptrs.emplace_back(block.get_by_position(arguments[i +
1]).column);
}
// if case_column/when_column is nullable. cast all
case_column/when_column to nullable.
@@ -231,7 +231,7 @@ public:
}
}
} else {
- auto* __restrict cond_raw_data =
+ const auto* __restrict cond_raw_data =
assert_cast<const
ColumnUInt8*>(when_column_ptr.get())
->get_data()
.data();
@@ -316,9 +316,8 @@ public:
void update_result_auto_simd(MutableColumnPtr& result_column_ptr,
const uint8* __restrict then_idx,
CaseWhenColumnHolder& column_holder) const {
- for (size_t i = 0; i < column_holder.then_ptrs.size(); i++) {
- column_holder.then_ptrs[i]->reset(
-
column_holder.then_ptrs[i].value()->convert_to_full_column_if_const());
+ for (auto& then_ptr : column_holder.then_ptrs) {
+
then_ptr->reset(then_ptr.value()->convert_to_full_column_if_const());
}
size_t rows_count = column_holder.rows_count;
diff --git a/be/src/vec/functions/function_date_or_datetime_computation.cpp
b/be/src/vec/functions/function_date_or_datetime_computation.cpp
index 6ec5db65889..2644b2bf3fe 100644
--- a/be/src/vec/functions/function_date_or_datetime_computation.cpp
+++ b/be/src/vec/functions/function_date_or_datetime_computation.cpp
@@ -68,34 +68,10 @@ struct NowFunctionName {
static constexpr auto name = "now";
};
-struct CurrentTimestampFunctionName {
- static constexpr auto name = "current_timestamp";
-};
-
-struct LocalTimeFunctionName {
- static constexpr auto name = "localtime";
-};
-
-struct LocalTimestampFunctionName {
- static constexpr auto name = "localtimestamp";
-};
-
using FunctionNow =
FunctionCurrentDateOrDateTime<CurrentDateTimeImpl<NowFunctionName, false>>;
-using FunctionCurrentTimestamp =
-
FunctionCurrentDateOrDateTime<CurrentDateTimeImpl<CurrentTimestampFunctionName,
false>>;
-using FunctionLocalTime =
-
FunctionCurrentDateOrDateTime<CurrentDateTimeImpl<LocalTimeFunctionName,
false>>;
-using FunctionLocalTimestamp =
-
FunctionCurrentDateOrDateTime<CurrentDateTimeImpl<LocalTimestampFunctionName,
false>>;
using FunctionNowWithPrecision =
FunctionCurrentDateOrDateTime<CurrentDateTimeImpl<NowFunctionName,
true>>;
-using FunctionCurrentTimestampWithPrecision =
-
FunctionCurrentDateOrDateTime<CurrentDateTimeImpl<CurrentTimestampFunctionName,
true>>;
-using FunctionLocalTimeWithPrecision =
-
FunctionCurrentDateOrDateTime<CurrentDateTimeImpl<LocalTimeFunctionName, true>>;
-using FunctionLocalTimestampWithPrecision =
-
FunctionCurrentDateOrDateTime<CurrentDateTimeImpl<LocalTimestampFunctionName,
true>>;
using FunctionNowWithPrecisionOld =
FunctionCurrentDateOrDateTimeOld<CurrentDateTimeImpl<NowFunctionName,
true>>;
@@ -104,13 +80,6 @@ struct CurDateFunctionName {
static constexpr auto name = "curdate";
};
-struct CurrentDateFunctionName {
- static constexpr auto name = "current_date";
-};
-
-FunctionBuilderPtr createCurrentDateFunctionBuilderFunction() {
- return
std::make_shared<CurrentDateFunctionBuilder<CurrentDateFunctionName>>();
-}
FunctionBuilderPtr createCurDateFunctionBuilderFunction() {
return std::make_shared<CurrentDateFunctionBuilder<CurDateFunctionName>>();
}
@@ -118,12 +87,8 @@ FunctionBuilderPtr createCurDateFunctionBuilderFunction() {
struct CurTimeFunctionName {
static constexpr auto name = "curtime";
};
-struct CurrentTimeFunctionName {
- static constexpr auto name = "current_time";
-};
using FunctionCurTime =
FunctionCurrentDateOrDateTime<CurrentTimeImpl<CurTimeFunctionName>>;
-using FunctionCurrentTime =
FunctionCurrentDateOrDateTime<CurrentTimeImpl<CurrentTimeFunctionName>>;
using FunctionUtcTimeStamp = FunctionCurrentDateOrDateTime<UtcTimestampImpl>;
using FunctionTimeToSec = FunctionCurrentDateOrDateTime<TimeToSecImpl>;
using FunctionSecToTime = FunctionCurrentDateOrDateTime<SecToTimeImpl>;
@@ -145,8 +110,6 @@ void
register_function_date_time_computation(SimpleFunctionFactory& factory) {
factory.register_function<FunctionSubMinutes>();
factory.register_function<FunctionSubHours>();
factory.register_function<FunctionSubDays>();
- factory.register_alias("days_sub", "date_sub");
- factory.register_alias("days_sub", "subdate");
factory.register_function<FunctionSubMonths>();
factory.register_function<FunctionSubYears>();
factory.register_function<FunctionSubQuarters>();
@@ -166,18 +129,9 @@ void
register_function_date_time_computation(SimpleFunctionFactory& factory) {
factory.register_function<FunctionToWeekTwoArgs>();
factory.register_function<FunctionNow>();
- factory.register_function<FunctionCurrentTimestamp>();
- factory.register_function<FunctionLocalTime>();
- factory.register_function<FunctionLocalTimestamp>();
factory.register_function<FunctionNowWithPrecision>();
- factory.register_function<FunctionCurrentTimestampWithPrecision>();
- factory.register_function<FunctionLocalTimeWithPrecision>();
- factory.register_function<FunctionLocalTimestampWithPrecision>();
- factory.register_function(CurrentDateFunctionName::name,
- &createCurrentDateFunctionBuilderFunction);
factory.register_function(CurDateFunctionName::name,
&createCurDateFunctionBuilderFunction);
factory.register_function<FunctionCurTime>();
- factory.register_function<FunctionCurrentTime>();
factory.register_function<FunctionUtcTimeStamp>();
factory.register_function<FunctionTimeToSec>();
factory.register_function<FunctionSecToTime>();
@@ -187,10 +141,16 @@ void
register_function_date_time_computation(SimpleFunctionFactory& factory) {
factory.register_alternative_function<FunctionNowWithPrecisionOld>();
- // alias
factory.register_alias("days_add", "date_add");
factory.register_alias("days_add", "adddate");
factory.register_alias("months_add", "add_months");
+ factory.register_alias("days_sub", "date_sub");
+ factory.register_alias("days_sub", "subdate");
+ factory.register_alias("now", "current_timestamp");
+ factory.register_alias("now", "localtime");
+ factory.register_alias("now", "localtimestamp");
+ factory.register_alias("curdate", "current_date");
+ factory.register_alias("curtime", "current_time");
}
} // namespace doris::vectorized
diff --git a/be/src/vec/functions/function_date_or_datetime_computation.h
b/be/src/vec/functions/function_date_or_datetime_computation.h
index 92a70bc8c92..916e9e1003f 100644
--- a/be/src/vec/functions/function_date_or_datetime_computation.h
+++ b/be/src/vec/functions/function_date_or_datetime_computation.h
@@ -889,13 +889,14 @@ struct CurrentDateTimeImpl {
} else if (const auto* nullable_column =
check_and_get_column<ColumnNullable>(
block.get_by_position(arguments[0]).column)) {
const auto& null_map = nullable_column->get_null_map_data();
- const auto& nested_column =
nullable_column->get_nested_column_ptr();
+ const auto& nested_column = assert_cast<const ColumnInt32*>(
+ nullable_column->get_nested_column_ptr().get());
for (int i = 0; i < input_rows_count; i++) {
if (!null_map[i]) {
dtv.from_unixtime(context->state()->timestamp_ms() /
1000,
context->state()->nano_seconds(),
context->state()->timezone_obj(),
- nested_column->get64(i));
+ nested_column->get_element(i));
if constexpr (std::is_same_v<DateValueType,
VecDateTimeValue>) {
reinterpret_cast<DateValueType*>(&dtv)->set_type(TIME_DATETIME);
}
@@ -911,11 +912,12 @@ struct CurrentDateTimeImpl {
}
use_const = false;
} else {
- auto& int_column = block.get_by_position(arguments[0]).column;
+ const auto* int_column = assert_cast<const ColumnInt32*>(
+ block.get_by_position(arguments[0]).column.get());
for (int i = 0; i < input_rows_count; i++) {
dtv.from_unixtime(context->state()->timestamp_ms() / 1000,
context->state()->nano_seconds(),
- context->state()->timezone_obj(),
int_column->get64(i));
+ context->state()->timezone_obj(),
int_column->get_element(i));
if constexpr (std::is_same_v<DateValueType,
VecDateTimeValue>) {
reinterpret_cast<DateValueType*>(&dtv)->set_type(TIME_DATETIME);
}
@@ -1019,7 +1021,7 @@ struct CurrentTimeImpl {
static constexpr auto name = FunctionName::name;
static Status execute(FunctionContext* context, Block& block, const
ColumnNumbers& arguments,
size_t result, size_t input_rows_count) {
- auto col_to = ColumnVector<Float64>::create();
+ auto col_to = ColumnFloat64::create();
VecDateTimeValue dtv;
dtv.from_unixtime(context->state()->timestamp_ms() / 1000,
context->state()->timezone_obj());
diff --git a/be/src/vec/functions/function_string.h
b/be/src/vec/functions/function_string.h
index 10db09fc91d..5be0b88de62 100644
--- a/be/src/vec/functions/function_string.h
+++ b/be/src/vec/functions/function_string.h
@@ -2914,8 +2914,7 @@ public:
std::mt19937 gen(rd());
for (size_t i = 0; i < input_rows_count; ++i) {
- UInt64 length = length_col->get64(i);
- random_bytes.resize(length);
+ random_bytes.resize(length_col->get_element(i));
std::uniform_int_distribution<uint8_t> distribution(0, 255);
for (auto& byte : random_bytes) {
@@ -3100,7 +3099,7 @@ struct MoneyFormatDoubleImpl {
static void execute(FunctionContext* context, ColumnString* result_column,
const ColumnPtr col_ptr, size_t input_rows_count) {
- const auto* data_column = assert_cast<const
ColumnVector<Float64>*>(col_ptr.get());
+ const auto* data_column = assert_cast<const
ColumnFloat64*>(col_ptr.get());
// when scale is above 38, we will go here
for (size_t i = 0; i < input_rows_count; i++) {
// round to 2 decimal places
diff --git a/be/src/vec/functions/functions_geo.cpp
b/be/src/vec/functions/functions_geo.cpp
index 172f000928f..036033db2a2 100644
--- a/be/src/vec/functions/functions_geo.cpp
+++ b/be/src/vec/functions/functions_geo.cpp
@@ -26,6 +26,7 @@
#include "geo/geo_common.h"
#include "geo/geo_types.h"
#include "vec/columns/column.h"
+#include "vec/columns/columns_number.h"
#include "vec/common/string_ref.h"
#include "vec/core/block.h"
#include "vec/core/column_with_type_and_name.h"
@@ -496,9 +497,12 @@ struct StCircle {
auto return_type = block.get_data_type(result);
auto center_lng =
block.get_by_position(arguments[0]).column->convert_to_full_column_if_const();
+ const auto* center_lng_ptr = assert_cast<const
ColumnFloat64*>(center_lng.get());
auto center_lat =
block.get_by_position(arguments[1]).column->convert_to_full_column_if_const();
+ const auto* center_lat_ptr = assert_cast<const
ColumnFloat64*>(center_lat.get());
auto radius =
block.get_by_position(arguments[2]).column->convert_to_full_column_if_const();
+ const auto* radius_ptr = assert_cast<const
ColumnFloat64*>(radius.get());
const auto size = center_lng->size();
@@ -507,9 +511,9 @@ struct StCircle {
GeoCircle circle;
std::string buf;
for (int row = 0; row < size; ++row) {
- auto lng_value = center_lng->get_float64(row);
- auto lat_value = center_lat->get_float64(row);
- auto radius_value = radius->get_float64(row);
+ auto lng_value = center_lng_ptr->get_element(row);
+ auto lat_value = center_lat_ptr->get_element(row);
+ auto radius_value = radius_ptr->get_element(row);
auto value = circle.init(lng_value, lat_value, radius_value);
if (value != GEO_PARSE_OK) {
diff --git a/be/src/vec/functions/functions_logical.cpp
b/be/src/vec/functions/functions_logical.cpp
index 87ccb6e1560..68f4f0a7596 100644
--- a/be/src/vec/functions/functions_logical.cpp
+++ b/be/src/vec/functions/functions_logical.cpp
@@ -55,7 +55,7 @@ using namespace FunctionsLogicalDetail;
template <class Op>
void vector_const(const IColumn* left, const ColumnConst* right, IColumn* res,
size_t rows) {
const auto* __restrict l_datas = assert_cast<const
ColumnUInt8*>(left)->get_data().data();
- auto r_data = (uint8)right->get_uint(0);
+ auto r_data = (uint8_t)right->get_bool(0);
auto* __restrict res_datas =
assert_cast<ColumnUInt8*>(res)->get_data().data();
for (size_t i = 0; i < rows; ++i) {
diff --git a/be/src/vec/functions/random.cpp b/be/src/vec/functions/random.cpp
index 564a51d932c..f073491e372 100644
--- a/be/src/vec/functions/random.cpp
+++ b/be/src/vec/functions/random.cpp
@@ -68,13 +68,12 @@ public:
if (scope == FunctionContext::THREAD_LOCAL) {
if (context->get_num_args() == 1) {
// This is a call to RandSeed, initialize the seed
- // TODO: should we support non-constant seed?
if (!context->is_col_constant(0)) {
return Status::InvalidArgument("Seed argument to rand()
must be constant.");
}
uint32_t seed = 0;
if (!context->get_constant_col(0)->column_ptr->is_null_at(0)) {
- seed = context->get_constant_col(0)->column_ptr->get64(0);
+ seed =
(*context->get_constant_col(0)->column_ptr)[0].get<int64_t>();
}
generator->seed(seed);
} else {
diff --git a/be/test/vec/data_types/serde/data_type_serde_pb_test.cpp
b/be/test/vec/data_types/serde/data_type_serde_pb_test.cpp
index a11b25291e6..b64ddee1d2c 100644
--- a/be/test/vec/data_types/serde/data_type_serde_pb_test.cpp
+++ b/be/test/vec/data_types/serde/data_type_serde_pb_test.cpp
@@ -112,7 +112,7 @@ TEST(DataTypeSerDePbTest, DataTypeScalaSerDeTest2) {
std::cout << "==== double === " << std::endl;
// double
{
- auto vec = vectorized::ColumnVector<Float64>::create();
+ auto vec = vectorized::ColumnFloat64::create();
auto& data = vec->get_data();
for (int i = 0; i < 10; ++i) {
data.push_back(i);
diff --git a/be/test/vec/exprs/vexpr_test.cpp b/be/test/vec/exprs/vexpr_test.cpp
index bc18fa30f4b..cc26356d91a 100644
--- a/be/test/vec/exprs/vexpr_test.cpp
+++ b/be/test/vec/exprs/vexpr_test.cpp
@@ -40,6 +40,7 @@
#include "runtime/large_int_value.h"
#include "runtime/runtime_state.h"
#include "testutil/desc_tbl_builder.h"
+#include "vec/columns/columns_number.h"
#include "vec/core/field.h"
#include "vec/core/types.h"
#include "vec/exprs/vexpr_context.h"
@@ -376,12 +377,11 @@ TEST(TEST_VEXPR, LITERALTEST) {
// bool
{
VLiteral literal(create_literal<TYPE_BOOLEAN>(true));
- std::cout << "data type: " << literal.data_type().get()->get_name() <<
std::endl;
Block block;
int ret = -1;
static_cast<void>(literal.execute(nullptr, &block, &ret));
auto ctn = block.safe_get_by_position(ret);
- bool v = ctn.column->get_bool(0);
+ auto v = (*ctn.column)[0].get<uint8_t>();
EXPECT_EQ(v, true);
EXPECT_EQ("1", literal.value());
}
@@ -392,7 +392,7 @@ TEST(TEST_VEXPR, LITERALTEST) {
int ret = -1;
static_cast<void>(literal.execute(nullptr, &block, &ret));
auto ctn = block.safe_get_by_position(ret);
- auto v = ctn.column->get64(0);
+ auto v = (*ctn.column)[0].get<int16_t>();
EXPECT_EQ(v, 1024);
EXPECT_EQ("1024", literal.value());
}
@@ -403,7 +403,7 @@ TEST(TEST_VEXPR, LITERALTEST) {
int ret = -1;
static_cast<void>(literal.execute(nullptr, &block, &ret));
auto ctn = block.safe_get_by_position(ret);
- auto v = ctn.column->get64(0);
+ auto v = (*ctn.column)[0].get<int32_t>();
EXPECT_EQ(v, 1024);
EXPECT_EQ("1024", literal.value());
}
@@ -414,7 +414,7 @@ TEST(TEST_VEXPR, LITERALTEST) {
int ret = -1;
static_cast<void>(literal.execute(nullptr, &block, &ret));
auto ctn = block.safe_get_by_position(ret);
- auto v = ctn.column->get64(0);
+ auto v = (*ctn.column)[0].get<int64_t>();
EXPECT_EQ(v, 1024);
EXPECT_EQ("1024", literal.value());
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/CosineDistance.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/CosineDistance.java
index a87fde5eb79..9761f949297 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/CosineDistance.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/CosineDistance.java
@@ -25,13 +25,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSi
import org.apache.doris.nereids.trees.expressions.shape.UnaryExpression;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.types.ArrayType;
-import org.apache.doris.nereids.types.BigIntType;
import org.apache.doris.nereids.types.DoubleType;
-import org.apache.doris.nereids.types.FloatType;
-import org.apache.doris.nereids.types.IntegerType;
-import org.apache.doris.nereids.types.LargeIntType;
-import org.apache.doris.nereids.types.SmallIntType;
-import org.apache.doris.nereids.types.TinyIntType;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
@@ -45,18 +39,6 @@ public class CosineDistance extends ScalarFunction
implements ExplicitlyCastable
ComputePrecisionForArrayItemAgg, UnaryExpression, AlwaysNullable {
public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(TinyIntType.INSTANCE),
ArrayType.of(TinyIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(SmallIntType.INSTANCE),
ArrayType.of(SmallIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(IntegerType.INSTANCE),
ArrayType.of(IntegerType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(BigIntType.INSTANCE),
ArrayType.of(BigIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(LargeIntType.INSTANCE),
ArrayType.of(LargeIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(FloatType.INSTANCE),
ArrayType.of(FloatType.INSTANCE)),
FunctionSignature.ret(DoubleType.INSTANCE)
.args(ArrayType.of(DoubleType.INSTANCE),
ArrayType.of(DoubleType.INSTANCE))
);
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/InnerProduct.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/InnerProduct.java
index 672a53859e8..5d226951cb1 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/InnerProduct.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/InnerProduct.java
@@ -25,13 +25,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSi
import org.apache.doris.nereids.trees.expressions.shape.UnaryExpression;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.types.ArrayType;
-import org.apache.doris.nereids.types.BigIntType;
import org.apache.doris.nereids.types.DoubleType;
-import org.apache.doris.nereids.types.FloatType;
-import org.apache.doris.nereids.types.IntegerType;
-import org.apache.doris.nereids.types.LargeIntType;
-import org.apache.doris.nereids.types.SmallIntType;
-import org.apache.doris.nereids.types.TinyIntType;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
@@ -45,18 +39,6 @@ public class InnerProduct extends ScalarFunction implements
ExplicitlyCastableSi
ComputePrecisionForArrayItemAgg, UnaryExpression, AlwaysNullable {
public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(TinyIntType.INSTANCE),
ArrayType.of(TinyIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(SmallIntType.INSTANCE),
ArrayType.of(SmallIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(IntegerType.INSTANCE),
ArrayType.of(IntegerType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(BigIntType.INSTANCE),
ArrayType.of(BigIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(LargeIntType.INSTANCE),
ArrayType.of(LargeIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(FloatType.INSTANCE),
ArrayType.of(FloatType.INSTANCE)),
FunctionSignature.ret(DoubleType.INSTANCE)
.args(ArrayType.of(DoubleType.INSTANCE),
ArrayType.of(DoubleType.INSTANCE))
);
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/L1Distance.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/L1Distance.java
index c583a7bb4f6..7423702fc7b 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/L1Distance.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/L1Distance.java
@@ -25,13 +25,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSi
import org.apache.doris.nereids.trees.expressions.shape.UnaryExpression;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.types.ArrayType;
-import org.apache.doris.nereids.types.BigIntType;
import org.apache.doris.nereids.types.DoubleType;
-import org.apache.doris.nereids.types.FloatType;
-import org.apache.doris.nereids.types.IntegerType;
-import org.apache.doris.nereids.types.LargeIntType;
-import org.apache.doris.nereids.types.SmallIntType;
-import org.apache.doris.nereids.types.TinyIntType;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
@@ -45,18 +39,6 @@ public class L1Distance extends ScalarFunction implements
ExplicitlyCastableSign
ComputePrecisionForArrayItemAgg, UnaryExpression, AlwaysNullable {
public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(TinyIntType.INSTANCE),
ArrayType.of(TinyIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(SmallIntType.INSTANCE),
ArrayType.of(SmallIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(IntegerType.INSTANCE),
ArrayType.of(IntegerType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(BigIntType.INSTANCE),
ArrayType.of(BigIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(LargeIntType.INSTANCE),
ArrayType.of(LargeIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(FloatType.INSTANCE),
ArrayType.of(FloatType.INSTANCE)),
FunctionSignature.ret(DoubleType.INSTANCE)
.args(ArrayType.of(DoubleType.INSTANCE),
ArrayType.of(DoubleType.INSTANCE))
);
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/L2Distance.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/L2Distance.java
index 64159c41bcc..14ffee389ae 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/L2Distance.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/L2Distance.java
@@ -25,13 +25,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSi
import org.apache.doris.nereids.trees.expressions.shape.UnaryExpression;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.types.ArrayType;
-import org.apache.doris.nereids.types.BigIntType;
import org.apache.doris.nereids.types.DoubleType;
-import org.apache.doris.nereids.types.FloatType;
-import org.apache.doris.nereids.types.IntegerType;
-import org.apache.doris.nereids.types.LargeIntType;
-import org.apache.doris.nereids.types.SmallIntType;
-import org.apache.doris.nereids.types.TinyIntType;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
@@ -45,18 +39,6 @@ public class L2Distance extends ScalarFunction implements
ExplicitlyCastableSign
ComputePrecisionForArrayItemAgg, UnaryExpression, AlwaysNullable {
public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(TinyIntType.INSTANCE),
ArrayType.of(TinyIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(SmallIntType.INSTANCE),
ArrayType.of(SmallIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(IntegerType.INSTANCE),
ArrayType.of(IntegerType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(BigIntType.INSTANCE),
ArrayType.of(BigIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(LargeIntType.INSTANCE),
ArrayType.of(LargeIntType.INSTANCE)),
- FunctionSignature.ret(DoubleType.INSTANCE)
- .args(ArrayType.of(FloatType.INSTANCE),
ArrayType.of(FloatType.INSTANCE)),
FunctionSignature.ret(DoubleType.INSTANCE)
.args(ArrayType.of(DoubleType.INSTANCE),
ArrayType.of(DoubleType.INSTANCE))
);
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For additional commands, e-mail: commits-h...@doris.apache.org
