thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-11-26 01:22:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

IColumn::index() function, "limit" parameter: change type UInt64 -> size_t.

Browse Source
This commit is contained in:
Vitaly Baranov 2019-02-18 20:28:53 +03:00
parent ab7e7507a4
commit 833aa9189b
24 changed files with 40 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dbms/src/Columns/ColumnAggregateFunction.cpp
View File

@ -205,13 +205,13 @@ ColumnPtr ColumnAggregateFunction::permute(const Permutation & perm, UInt64 limi
return res; return res;
} }
ColumnPtr ColumnAggregateFunction::index(const IColumn & indexes, UInt64 limit) const ColumnPtr ColumnAggregateFunction::index(const IColumn & indexes, size_t limit) const
{ {
return selectIndexImpl(*this, indexes, limit); return selectIndexImpl(*this, indexes, limit);
} }
template <typename Type> template <typename Type>
ColumnPtr ColumnAggregateFunction::indexImpl(const PaddedPODArray<Type> & indexes, UInt64 limit) const ColumnPtr ColumnAggregateFunction::indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const
{ {
auto res = createView(); auto res = createView();

4
dbms/src/Columns/ColumnAggregateFunction.h
View File

@ -165,10 +165,10 @@ public:
ColumnPtr permute(const Permutation & perm, UInt64 limit) const override; ColumnPtr permute(const Permutation & perm, UInt64 limit) const override;
ColumnPtr index(const IColumn & indexes, UInt64 limit) const override; ColumnPtr index(const IColumn & indexes, size_t limit) const override;
template <typename Type> template <typename Type>
ColumnPtr indexImpl(const PaddedPODArray<Type> & indexes, UInt64 limit) const; ColumnPtr indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const;
ColumnPtr replicate(const Offsets & offsets) const override; ColumnPtr replicate(const Offsets & offsets) const override;

4
dbms/src/Columns/ColumnArray.cpp
View File

@ -626,13 +626,13 @@ ColumnPtr ColumnArray::permute(const Permutation & perm, UInt64 limit) const
return res; return res;
} }
ColumnPtr ColumnArray::index(const IColumn & indexes, UInt64 limit) const ColumnPtr ColumnArray::index(const IColumn & indexes, size_t limit) const
{ {
return selectIndexImpl(*this, indexes, limit); return selectIndexImpl(*this, indexes, limit);
} }
template <typename T> template <typename T>
ColumnPtr ColumnArray::indexImpl(const PaddedPODArray<T> & indexes, UInt64 limit) const ColumnPtr ColumnArray::indexImpl(const PaddedPODArray<T> & indexes, size_t limit) const
{ {
if (limit == 0) if (limit == 0)
return ColumnArray::create(data); return ColumnArray::create(data);

4
dbms/src/Columns/ColumnArray.h
View File

@ -71,8 +71,8 @@ public:
void popBack(size_t n) override; void popBack(size_t n) override;
ColumnPtr filter(const Filter & filt, ssize_t result_size_hint) const override; ColumnPtr filter(const Filter & filt, ssize_t result_size_hint) const override;
ColumnPtr permute(const Permutation & perm, UInt64 limit) const override; ColumnPtr permute(const Permutation & perm, UInt64 limit) const override;
ColumnPtr index(const IColumn & indexes, UInt64 limit) const override; ColumnPtr index(const IColumn & indexes, size_t limit) const override;
template <typename Type> ColumnPtr indexImpl(const PaddedPODArray<Type> & indexes, UInt64 limit) const; template <typename Type> ColumnPtr indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const;
int compareAt(size_t n, size_t m, const IColumn & rhs_, int nan_direction_hint) const override; int compareAt(size_t n, size_t m, const IColumn & rhs_, int nan_direction_hint) const override;
void getPermutation(bool reverse, UInt64 limit, int nan_direction_hint, Permutation & res) const override; void getPermutation(bool reverse, UInt64 limit, int nan_direction_hint, Permutation & res) const override;
void reserve(size_t n) override; void reserve(size_t n) override;

2
dbms/src/Columns/ColumnConst.cpp
View File

@ -68,7 +68,7 @@ ColumnPtr ColumnConst::permute(const Permutation & perm, UInt64 limit) const
return ColumnConst::create(data, limit); return ColumnConst::create(data, limit);
} }
ColumnPtr ColumnConst::index(const IColumn & indexes, UInt64 limit) const ColumnPtr ColumnConst::index(const IColumn & indexes, size_t limit) const
{ {
if (limit == 0) if (limit == 0)
limit = indexes.size(); limit = indexes.size();

2
dbms/src/Columns/ColumnConst.h
View File

@ -155,7 +155,7 @@ public:
ColumnPtr filter(const Filter & filt, ssize_t result_size_hint) const override; ColumnPtr filter(const Filter & filt, ssize_t result_size_hint) const override;
ColumnPtr replicate(const Offsets & offsets) const override; ColumnPtr replicate(const Offsets & offsets) const override;
ColumnPtr permute(const Permutation & perm, UInt64 limit) const override; ColumnPtr permute(const Permutation & perm, UInt64 limit) const override;
ColumnPtr index(const IColumn & indexes, UInt64 limit) const override; ColumnPtr index(const IColumn & indexes, size_t limit) const override;
void getPermutation(bool reverse, UInt64 limit, int nan_direction_hint, Permutation & res) const override; void getPermutation(bool reverse, UInt64 limit, int nan_direction_hint, Permutation & res) const override;
size_t byteSize() const override size_t byteSize() const override

2
dbms/src/Columns/ColumnDecimal.cpp
View File

@ -173,7 +173,7 @@ ColumnPtr ColumnDecimal<T>::filter(const IColumn::Filter & filt, ssize_t result_
} }
template <typename T> template <typename T>
ColumnPtr ColumnDecimal<T>::index(const IColumn & indexes, UInt64 limit) const ColumnPtr ColumnDecimal<T>::index(const IColumn & indexes, size_t limit) const
{ {
return selectIndexImpl(*this, indexes, limit); return selectIndexImpl(*this, indexes, limit);
} }

6
dbms/src/Columns/ColumnDecimal.h
View File

@ -117,10 +117,10 @@ public:
ColumnPtr filter(const IColumn::Filter & filt, ssize_t result_size_hint) const override; ColumnPtr filter(const IColumn::Filter & filt, ssize_t result_size_hint) const override;
ColumnPtr permute(const IColumn::Permutation & perm, UInt64 limit) const override; ColumnPtr permute(const IColumn::Permutation & perm, UInt64 limit) const override;
ColumnPtr index(const IColumn & indexes, UInt64 limit) const override; ColumnPtr index(const IColumn & indexes, size_t limit) const override;
template <typename Type> template <typename Type>
ColumnPtr indexImpl(const PaddedPODArray<Type> & indexes, UInt64 limit) const; ColumnPtr indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const;
ColumnPtr replicate(const IColumn::Offsets & offsets) const override; ColumnPtr replicate(const IColumn::Offsets & offsets) const override;
void getExtremes(Field & min, Field & max) const override; void getExtremes(Field & min, Field & max) const override;
@ -164,7 +164,7 @@ protected:
template <typename T> template <typename T>
template <typename Type> template <typename Type>
ColumnPtr ColumnDecimal<T>::indexImpl(const PaddedPODArray<Type> & indexes, UInt64 limit) const ColumnPtr ColumnDecimal<T>::indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const
{ {
size_t size = indexes.size(); size_t size = indexes.size();

4
dbms/src/Columns/ColumnFixedString.cpp
View File

@ -260,14 +260,14 @@ ColumnPtr ColumnFixedString::permute(const Permutation & perm, UInt64 limit) con
} }
ColumnPtr ColumnFixedString::index(const IColumn & indexes, UInt64 limit) const ColumnPtr ColumnFixedString::index(const IColumn & indexes, size_t limit) const
{ {
return selectIndexImpl(*this, indexes, limit); return selectIndexImpl(*this, indexes, limit);
} }
template <typename Type> template <typename Type>
ColumnPtr ColumnFixedString::indexImpl(const PaddedPODArray<Type> & indexes, UInt64 limit) const ColumnPtr ColumnFixedString::indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const
{ {
if (limit == 0) if (limit == 0)
return ColumnFixedString::create(n); return ColumnFixedString::create(n);

4
dbms/src/Columns/ColumnFixedString.h
View File

@ -109,10 +109,10 @@ public:
ColumnPtr permute(const Permutation & perm, UInt64 limit) const override; ColumnPtr permute(const Permutation & perm, UInt64 limit) const override;
ColumnPtr index(const IColumn & indexes, UInt64 limit) const override; ColumnPtr index(const IColumn & indexes, size_t limit) const override;
template <typename Type> template <typename Type>
ColumnPtr indexImpl(const PaddedPODArray<Type> & indexes, UInt64 limit) const; ColumnPtr indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const;
ColumnPtr replicate(const Offsets & offsets) const override; ColumnPtr replicate(const Offsets & offsets) const override;

2
dbms/src/Columns/ColumnFunction.cpp
View File

@ -88,7 +88,7 @@ ColumnPtr ColumnFunction::permute(const Permutation & perm, UInt64 limit) const
return ColumnFunction::create(limit, function, capture); return ColumnFunction::create(limit, function, capture);
} }
ColumnPtr ColumnFunction::index(const IColumn & indexes, UInt64 limit) const ColumnPtr ColumnFunction::index(const IColumn & indexes, size_t limit) const
{ {
ColumnsWithTypeAndName capture = captured_columns; ColumnsWithTypeAndName capture = captured_columns;
for (auto & column : capture) for (auto & column : capture)

2
dbms/src/Columns/ColumnFunction.h
View File

@ -33,7 +33,7 @@ public:
ColumnPtr replicate(const Offsets & offsets) const override; ColumnPtr replicate(const Offsets & offsets) const override;
ColumnPtr filter(const Filter & filt, ssize_t result_size_hint) const override; ColumnPtr filter(const Filter & filt, ssize_t result_size_hint) const override;
ColumnPtr permute(const Permutation & perm, UInt64 limit) const override; ColumnPtr permute(const Permutation & perm, UInt64 limit) const override;
ColumnPtr index(const IColumn & indexes, UInt64 limit) const override; ColumnPtr index(const IColumn & indexes, size_t limit) const override;
void insertDefault() override; void insertDefault() override;
void popBack(size_t n) override; void popBack(size_t n) override;
std::vector<MutableColumnPtr> scatter(IColumn::ColumnIndex num_columns, std::vector<MutableColumnPtr> scatter(IColumn::ColumnIndex num_columns,

2
dbms/src/Columns/ColumnLowCardinality.h
View File

@ -95,7 +95,7 @@ public:
return ColumnLowCardinality::create(dictionary.getColumnUniquePtr(), getIndexes().permute(perm, limit)); return ColumnLowCardinality::create(dictionary.getColumnUniquePtr(), getIndexes().permute(perm, limit));
} }
ColumnPtr index(const IColumn & indexes_, UInt64 limit) const override ColumnPtr index(const IColumn & indexes_, size_t limit) const override
{ {
return ColumnLowCardinality::create(dictionary.getColumnUniquePtr(), getIndexes().index(indexes_, limit)); return ColumnLowCardinality::create(dictionary.getColumnUniquePtr(), getIndexes().index(indexes_, limit));
} }

2
dbms/src/Columns/ColumnNullable.cpp
View File

@ -165,7 +165,7 @@ ColumnPtr ColumnNullable::permute(const Permutation & perm, UInt64 limit) const
return ColumnNullable::create(permuted_data, permuted_null_map); return ColumnNullable::create(permuted_data, permuted_null_map);
} }
ColumnPtr ColumnNullable::index(const IColumn & indexes, UInt64 limit) const ColumnPtr ColumnNullable::index(const IColumn & indexes, size_t limit) const
{ {
ColumnPtr indexed_data = getNestedColumn().index(indexes, limit); ColumnPtr indexed_data = getNestedColumn().index(indexes, limit);
ColumnPtr indexed_null_map = getNullMapColumn().index(indexes, limit); ColumnPtr indexed_null_map = getNullMapColumn().index(indexes, limit);

2
dbms/src/Columns/ColumnNullable.h
View File

@ -65,7 +65,7 @@ public:
void popBack(size_t n) override; void popBack(size_t n) override;
ColumnPtr filter(const Filter & filt, ssize_t result_size_hint) const override; ColumnPtr filter(const Filter & filt, ssize_t result_size_hint) const override;
ColumnPtr permute(const Permutation & perm, UInt64 limit) const override; ColumnPtr permute(const Permutation & perm, UInt64 limit) const override;
ColumnPtr index(const IColumn & indexes, UInt64 limit) const override; ColumnPtr index(const IColumn & indexes, size_t limit) const override;
int compareAt(size_t n, size_t m, const IColumn & rhs_, int null_direction_hint) const override; int compareAt(size_t n, size_t m, const IColumn & rhs_, int null_direction_hint) const override;
void getPermutation(bool reverse, UInt64 limit, int null_direction_hint, Permutation & res) const override; void getPermutation(bool reverse, UInt64 limit, int null_direction_hint, Permutation & res) const override;
void reserve(size_t n) override; void reserve(size_t n) override;

4
dbms/src/Columns/ColumnString.cpp
View File

@ -191,13 +191,13 @@ const char * ColumnString::deserializeAndInsertFromArena(const char * pos)
} }
ColumnPtr ColumnString::index(const IColumn & indexes, UInt64 limit) const ColumnPtr ColumnString::index(const IColumn & indexes, size_t limit) const
{ {
return selectIndexImpl(*this, indexes, limit); return selectIndexImpl(*this, indexes, limit);
} }
template <typename Type> template <typename Type>
ColumnPtr ColumnString::indexImpl(const PaddedPODArray<Type> & indexes, UInt64 limit) const ColumnPtr ColumnString::indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const
{ {
if (limit == 0) if (limit == 0)
return ColumnString::create(); return ColumnString::create();

4
dbms/src/Columns/ColumnString.h
View File

@ -196,10 +196,10 @@ public:
ColumnPtr permute(const Permutation & perm, UInt64 limit) const override; ColumnPtr permute(const Permutation & perm, UInt64 limit) const override;
ColumnPtr index(const IColumn & indexes, UInt64 limit) const override; ColumnPtr index(const IColumn & indexes, size_t limit) const override;
template <typename Type> template <typename Type>
ColumnPtr indexImpl(const PaddedPODArray<Type> & indexes, UInt64 limit) const; ColumnPtr indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const;
void insertDefault() override void insertDefault() override
{ {

2
dbms/src/Columns/ColumnTuple.cpp
View File

@ -181,7 +181,7 @@ ColumnPtr ColumnTuple::permute(const Permutation & perm, UInt64 limit) const
return ColumnTuple::create(new_columns); return ColumnTuple::create(new_columns);
} }
ColumnPtr ColumnTuple::index(const IColumn & indexes, UInt64 limit) const ColumnPtr ColumnTuple::index(const IColumn & indexes, size_t limit) const
{ {
const size_t tuple_size = columns.size(); const size_t tuple_size = columns.size();
Columns new_columns(tuple_size); Columns new_columns(tuple_size);

2
dbms/src/Columns/ColumnTuple.h
View File

@ -61,7 +61,7 @@ public:
void insertRangeFrom(const IColumn & src, size_t start, size_t length) override; void insertRangeFrom(const IColumn & src, size_t start, size_t length) override;
ColumnPtr filter(const Filter & filt, ssize_t result_size_hint) const override; ColumnPtr filter(const Filter & filt, ssize_t result_size_hint) const override;
ColumnPtr permute(const Permutation & perm, UInt64 limit) const override; ColumnPtr permute(const Permutation & perm, UInt64 limit) const override;
ColumnPtr index(const IColumn & indexes, UInt64 limit) const override; ColumnPtr index(const IColumn & indexes, size_t limit) const override;
ColumnPtr replicate(const Offsets & offsets) const override; ColumnPtr replicate(const Offsets & offsets) const override;
MutableColumns scatter(ColumnIndex num_columns, const Selector & selector) const override; MutableColumns scatter(ColumnIndex num_columns, const Selector & selector) const override;
void gather(ColumnGathererStream & gatherer_stream) override; void gather(ColumnGathererStream & gatherer_stream) override;

2
dbms/src/Columns/ColumnVector.cpp
View File

@ -230,7 +230,7 @@ ColumnPtr ColumnVector<T>::permute(const IColumn::Permutation & perm, UInt64 lim
} }
template <typename T> template <typename T>
ColumnPtr ColumnVector<T>::index(const IColumn & indexes, UInt64 limit) const ColumnPtr ColumnVector<T>::index(const IColumn & indexes, size_t limit) const
{ {
return selectIndexImpl(*this, indexes, limit); return selectIndexImpl(*this, indexes, limit);
} }

6
dbms/src/Columns/ColumnVector.h
View File

@ -223,10 +223,10 @@ public:
ColumnPtr permute(const IColumn::Permutation & perm, UInt64 limit) const override; ColumnPtr permute(const IColumn::Permutation & perm, UInt64 limit) const override;
ColumnPtr index(const IColumn & indexes, UInt64 limit) const override; ColumnPtr index(const IColumn & indexes, size_t limit) const override;
template <typename Type> template <typename Type>
ColumnPtr indexImpl(const PaddedPODArray<Type> & indexes, UInt64 limit) const; ColumnPtr indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const;
ColumnPtr replicate(const IColumn::Offsets & offsets) const override; ColumnPtr replicate(const IColumn::Offsets & offsets) const override;
@ -273,7 +273,7 @@ protected:
template <typename T> template <typename T>
template <typename Type> template <typename Type>
ColumnPtr ColumnVector<T>::indexImpl(const PaddedPODArray<Type> & indexes, UInt64 limit) const ColumnPtr ColumnVector<T>::indexImpl(const PaddedPODArray<Type> & indexes, size_t limit) const
{ {
size_t size = indexes.size(); size_t size = indexes.size();

10
dbms/src/Columns/ColumnsCommon.h
View File

@ -46,7 +46,7 @@ namespace detail
/// Check limit <= indexes->size() and call column.indexImpl(const PaddedPodArray<Type> & indexes, UInt64 limit). /// Check limit <= indexes->size() and call column.indexImpl(const PaddedPodArray<Type> & indexes, UInt64 limit).
template <typename Column> template <typename Column>
ColumnPtr selectIndexImpl(const Column & column, const IColumn & indexes, UInt64 limit) ColumnPtr selectIndexImpl(const Column & column, const IColumn & indexes, size_t limit)
{ {
if (limit == 0) if (limit == 0)
limit = indexes.size(); limit = indexes.size();
@ -68,8 +68,8 @@ ColumnPtr selectIndexImpl(const Column & column, const IColumn & indexes, UInt64
} }
#define INSTANTIATE_INDEX_IMPL(Column) \ #define INSTANTIATE_INDEX_IMPL(Column) \
template ColumnPtr Column::indexImpl<UInt8>(const PaddedPODArray<UInt8> & indexes, UInt64 limit) const; \ template ColumnPtr Column::indexImpl<UInt8>(const PaddedPODArray<UInt8> & indexes, size_t limit) const; \
template ColumnPtr Column::indexImpl<UInt16>(const PaddedPODArray<UInt16> & indexes, UInt64 limit) const; \ template ColumnPtr Column::indexImpl<UInt16>(const PaddedPODArray<UInt16> & indexes, size_t limit) const; \
template ColumnPtr Column::indexImpl<UInt32>(const PaddedPODArray<UInt32> & indexes, UInt64 limit) const; \ template ColumnPtr Column::indexImpl<UInt32>(const PaddedPODArray<UInt32> & indexes, size_t limit) const; \
template ColumnPtr Column::indexImpl<UInt64>(const PaddedPODArray<UInt64> & indexes, UInt64 limit) const; template ColumnPtr Column::indexImpl<UInt64>(const PaddedPODArray<UInt64> & indexes, size_t limit) const;
} }

2
dbms/src/Columns/IColumn.h
View File

@ -188,7 +188,7 @@ public:
/// Creates new column with values column[indexes[:limit]]. If limit is 0, all indexes are used. /// 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 selectIndexImpl from ColumnsCommon.h /// Indexes must be one of the ColumnUInt. For default implementation, see selectIndexImpl from ColumnsCommon.h
virtual Ptr index(const IColumn & indexes, UInt64 limit) const = 0; virtual Ptr index(const IColumn & indexes, size_t limit) const = 0;
/** Compares (*this)[n] and rhs[m]. Column rhs should have the same type. /** 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. * Returns negative number, 0, or positive number (*this)[n] is less, equal, greater than rhs[m] respectively.

2
dbms/src/Columns/IColumnDummy.h
View File

@ -87,7 +87,7 @@ public:
return cloneDummy(limit ? std::min(s, limit) : s); return cloneDummy(limit ? std::min(s, limit) : s);
} }
ColumnPtr index(const IColumn & indexes, UInt64 limit) const override ColumnPtr index(const IColumn & indexes, size_t limit) const override
{ {
if (indexes.size() < limit) if (indexes.size() < limit)
throw Exception("Size of indexes is less than required.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH); throw Exception("Size of indexes is less than required.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);