tool
/
starrocks
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix override by clang-tidy (#358)

This commit is contained in:
Zhao Chun 2021-09-23 21:18:41 +08:00 committed by GitHub
parent b2a528a861
commit 86abd532ca
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
152 changed files with 868 additions and 885 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
be/src/agent/heartbeat_server.h
View File

@ -41,7 +41,7 @@ class ThriftServer;
class HeartbeatServer : public HeartbeatServiceIf {
public:
explicit HeartbeatServer(TMasterInfo* master_info);
virtual ~HeartbeatServer(){};
~HeartbeatServer() override{};
virtual void init_cluster_id();
@ -52,7 +52,7 @@ public:
//
// Output parameters:
// * heartbeat_result: The result of heartbeat set
virtual void heartbeat(THeartbeatResult& heartbeat_result, const TMasterInfo& master_info);
void heartbeat(THeartbeatResult& heartbeat_result, const TMasterInfo& master_info) override;
private:
Status _heartbeat(const TMasterInfo& master_info);

6
be/src/agent/multi_worker_pool.h
View File

@ -14,12 +14,12 @@ class MultiWorkerPool : public TaskWorkerPool {
public:
MultiWorkerPool(const TaskWorkerType worker_type, ExecEnv* env, const TMasterInfo& master_info, int worker_num);
virtual ~MultiWorkerPool(){};
~MultiWorkerPool() override{};
virtual void start();
void start() override;
// submit task to queue and wait to be executed
virtual void submit_task(const TAgentTaskRequest& task);
void submit_task(const TAgentTaskRequest& task) override;
private:
void submit_publish_version_task(const TAgentTaskRequest& task);

6
be/src/column/column.h
View File

@ -358,11 +358,13 @@ public:
return MutablePtr(new Derived(std::forward<std::initializer_list<T>>(arg)));
}
typename AncestorBaseType::MutablePtr clone() const {
typename AncestorBaseType::MutablePtr clone() const override {
return typename AncestorBase::MutablePtr(new Derived(*derived()));
}
typename AncestorBaseType::Ptr clone_shared() const { return typename AncestorBase::Ptr(new Derived(*derived())); }
typename AncestorBaseType::Ptr clone_shared() const override {
return typename AncestorBase::Ptr(new Derived(*derived()));
}
};
} // namespace vectorized

2
be/src/column/decimalv3_column.h
View File

@ -30,7 +30,7 @@ public:
MutableColumnPtr clone_empty() const override;
void put_mysql_row_buffer(MysqlRowBuffer* buf, size_t idx) const;
void put_mysql_row_buffer(MysqlRowBuffer* buf, size_t idx) const override;
std::string debug_item(uint32_t idx) const override;
void crc32_hash(uint32_t* hash, uint32_t from, uint32_t to) const override;

2
be/src/column/object_column.h
View File

@ -179,7 +179,7 @@ public:
const std::vector<T>& get_pool() const { return _pool; }
std::string debug_item(uint32_t idx) const;
std::string debug_item(uint32_t idx) const override;
std::string debug_string() const override {
std::stringstream ss;

4
be/src/env/env_posix.cpp vendored
View File

@ -409,9 +409,9 @@ public:
PosixRandomRWFile(string fname, int fd, bool sync_on_close)
: _filename(std::move(fname)), _fd(fd), _sync_on_close(sync_on_close), _closed(false) {}
~PosixRandomRWFile() { WARN_IF_ERROR(close(), "Failed to close " + _filename); }
~PosixRandomRWFile() override { WARN_IF_ERROR(close(), "Failed to close " + _filename); }
virtual Status read_at(uint64_t offset, const Slice& result) const override {
Status read_at(uint64_t offset, const Slice& result) const override {
return do_readv_at(_fd, _filename, offset, &result, 1, nullptr);
}

2
be/src/env/writable_file_wrapper.h vendored
View File

@ -12,7 +12,7 @@ public:
// |file| must outlive WritableFileWrapper.
explicit WritableFileWrapper(WritableFile* file, Ownership ownership) : _file(file), _ownership(ownership) {}
~WritableFileWrapper() {
~WritableFileWrapper() override {
if (_ownership == kTakesOwnership) {
delete _file;
}

8
be/src/exec/broker_writer.h
View File

@ -43,13 +43,13 @@ class BrokerWriter : public FileWriter {
public:
BrokerWriter(ExecEnv* env, const std::vector<TNetworkAddress>& broker_addresses,
const std::map<std::string, std::string>& properties, const std::string& path, int64_t start_offset);
virtual ~BrokerWriter();
~BrokerWriter() override;
virtual Status open() override;
Status open() override;
virtual Status write(const uint8_t* buf, size_t buf_len, size_t* written_len) override;
Status write(const uint8_t* buf, size_t buf_len, size_t* written_len) override;
virtual Status close() override;
Status close() override;
private:
ExecEnv* _env;

20
be/src/exec/buffered_reader.h
View File

@ -37,19 +37,19 @@ public:
// If the reader need the file size, set it when construct FileReader.
// There is no other way to set the file size.
BufferedReader(FileReader* reader, int64_t = 1024 * 1024);
virtual ~BufferedReader();
~BufferedReader() override;
virtual Status open() override;
Status open() override;
// Read
virtual Status read(uint8_t* buf, size_t* buf_len, bool* eof) override;
virtual Status readat(int64_t position, int64_t nbytes, int64_t* bytes_read, void* out) override;
virtual Status read_one_message(std::unique_ptr<uint8_t[]>* buf, size_t* length) override;
virtual int64_t size() override;
virtual Status seek(int64_t position) override;
virtual Status tell(int64_t* position) override;
virtual void close() override;
virtual bool closed() override;
Status read(uint8_t* buf, size_t* buf_len, bool* eof) override;
Status readat(int64_t position, int64_t nbytes, int64_t* bytes_read, void* out) override;
Status read_one_message(std::unique_ptr<uint8_t[]>* buf, size_t* length) override;
int64_t size() override;
Status seek(int64_t position) override;
Status tell(int64_t* position) override;
void close() override;
bool closed() override;
private:
Status _fill();

38
be/src/exec/decompressor.h
View File

@ -68,17 +68,17 @@ protected:
class GzipDecompressor : public Decompressor {
public:
virtual ~GzipDecompressor();
~GzipDecompressor() override;
virtual Status decompress(uint8_t* input, size_t input_len, size_t* input_bytes_read, uint8_t* output,
size_t output_len, size_t* output_bytes_written, bool* stream_end) override;
Status decompress(uint8_t* input, size_t input_len, size_t* input_bytes_read, uint8_t* output, size_t output_len,
size_t* output_bytes_written, bool* stream_end) override;
virtual std::string debug_info() override;
std::string debug_info() override;
private:
friend class Decompressor;
GzipDecompressor(bool is_deflate);
virtual Status init() override;
Status init() override;
private:
bool _is_deflate;
@ -92,17 +92,17 @@ private:
class Bzip2Decompressor : public Decompressor {
public:
virtual ~Bzip2Decompressor();
~Bzip2Decompressor() override;
virtual Status decompress(uint8_t* input, size_t input_len, size_t* input_bytes_read, uint8_t* output,
size_t output_len, size_t* output_bytes_written, bool* stream_end) override;
Status decompress(uint8_t* input, size_t input_len, size_t* input_bytes_read, uint8_t* output, size_t output_len,
size_t* output_bytes_written, bool* stream_end) override;
virtual std::string debug_info() override;
std::string debug_info() override;
private:
friend class Decompressor;
Bzip2Decompressor() : Decompressor(CompressionTypePB::BZIP2) {}
virtual Status init() override;
Status init() override;
private:
bz_stream _bz_strm;
@ -110,17 +110,17 @@ private:
class Lz4FrameDecompressor : public Decompressor {
public:
virtual ~Lz4FrameDecompressor();
~Lz4FrameDecompressor() override;
virtual Status decompress(uint8_t* input, size_t input_len, size_t* input_bytes_read, uint8_t* output,
size_t output_len, size_t* output_bytes_written, bool* stream_end) override;
Status decompress(uint8_t* input, size_t input_len, size_t* input_bytes_read, uint8_t* output, size_t output_len,
size_t* output_bytes_written, bool* stream_end) override;
virtual std::string debug_info() override;
std::string debug_info() override;
private:
friend class Decompressor;
Lz4FrameDecompressor() : Decompressor(CompressionTypePB::LZ4_FRAME) {}
virtual Status init() override;
Status init() override;
size_t get_block_size(const LZ4F_frameInfo_t* info);
@ -134,12 +134,12 @@ private:
/// It offers a very wide range of compression/speed trade-off.
class ZstandardDecompressor : public Decompressor {
public:
virtual ~ZstandardDecompressor();
~ZstandardDecompressor() override;
virtual Status decompress(uint8_t* input, size_t input_len, size_t* input_bytes_read, uint8_t* output,
size_t output_len, size_t* output_bytes_write, bool* stream_end) override;
Status decompress(uint8_t* input, size_t input_len, size_t* input_bytes_read, uint8_t* output, size_t output_len,
size_t* output_bytes_write, bool* stream_end) override;
virtual std::string debug_info() override;
std::string debug_info() override;
private:
friend class Decompressor;

6
be/src/exec/es/es_predicate.h
View File

@ -50,8 +50,8 @@ public:
class SExtLiteral : public ExtLiteral {
public:
SExtLiteral(PrimitiveType type, void* value) : _type(type), _value(value) { _str = value_to_string(); }
~SExtLiteral();
const std::string& to_string() const { return _str; }
~SExtLiteral() override;
const std::string& to_string() const override { return _str; }
private:
int8_t get_byte();
@ -82,7 +82,7 @@ public:
_value = _value_to_string(column);
}
VExtLiteral() = default;
const std::string& to_string() const { return _value; }
const std::string& to_string() const override { return _value; }
private:
static std::string _value_to_string(ColumnPtr& column);

2
be/src/exec/es/es_query_builder.h
View File

@ -118,7 +118,7 @@ class BooleanQueryBuilder : public QueryBuilder {
public:
BooleanQueryBuilder(const std::vector<ExtPredicate*>& predicates);
BooleanQueryBuilder();
virtual ~BooleanQueryBuilder();
~BooleanQueryBuilder() override;
// class method for transfer predicate to es query value, invoker should enclose this value with `query`
static void to_query(const std::vector<EsPredicate*>& predicates, rapidjson::Document* root,
rapidjson::Value* query);

2
be/src/exec/exchange_node.h
View File

@ -50,7 +50,7 @@ class RuntimeProfile;
class ExchangeNode final : public ExecNode {
public:
ExchangeNode(ObjectPool* pool, const TPlanNode& tnode, const DescriptorTbl& descs);
virtual ~ExchangeNode() {}
~ExchangeNode() override {}
Status init(const TPlanNode& tnode, RuntimeState* state = nullptr) override;
Status prepare(RuntimeState* state) override;

20
be/src/exec/local_file_reader.h
View File

@ -31,22 +31,22 @@ namespace starrocks {
class LocalFileReader : public FileReader {
public:
LocalFileReader(const std::string& path, int64_t start_offset);
virtual ~LocalFileReader();
~LocalFileReader() override;
virtual Status open() override;
Status open() override;
// Read content to 'buf', 'buf_len' is the max size of this buffer.
// Return ok when read success, and 'buf_len' is set to size of read content
// If reach to end of file, the eof is set to true. meanwhile 'buf_len'
// is set to zero.
virtual Status read(uint8_t* buf, size_t* buf_len, bool* eof) override;
virtual Status readat(int64_t position, int64_t nbytes, int64_t* bytes_read, void* out) override;
virtual Status read_one_message(std::unique_ptr<uint8_t[]>* buf, size_t* length) override;
virtual int64_t size() override;
virtual Status seek(int64_t position) override;
virtual Status tell(int64_t* position) override;
virtual void close() override;
virtual bool closed() override;
Status read(uint8_t* buf, size_t* buf_len, bool* eof) override;
Status readat(int64_t position, int64_t nbytes, int64_t* bytes_read, void* out) override;
Status read_one_message(std::unique_ptr<uint8_t[]>* buf, size_t* length) override;
int64_t size() override;
Status seek(int64_t position) override;
Status tell(int64_t* position) override;
void close() override;
bool closed() override;
private:
std::string _path;

6
be/src/exec/local_file_writer.h
View File

@ -33,13 +33,13 @@ class RuntimeState;
class LocalFileWriter : public FileWriter {
public:
LocalFileWriter(const std::string& path, int64_t start_offset);
virtual ~LocalFileWriter();
~LocalFileWriter() override;
Status open() override;
virtual Status write(const uint8_t* buf, size_t buf_len, size_t* written_len) override;
Status write(const uint8_t* buf, size_t buf_len, size_t* written_len) override;
virtual Status close() override;
Status close() override;
private:
std::string _path;

2
be/src/exec/parquet/column_reader.cpp
View File

@ -630,7 +630,7 @@ public:
return Status::OK();
}
void get_levels(level_t** def_levels, level_t** rep_levels, size_t* num_levels) {
void get_levels(level_t** def_levels, level_t** rep_levels, size_t* num_levels) override {
_element_reader->get_levels(def_levels, rep_levels, num_levels);
}

6
be/src/exec/parquet/stored_column_reader.cpp
View File

@ -68,7 +68,7 @@ class OptionalStoredColumnReader : public StoredColumnReader {
public:
OptionalStoredColumnReader(const StoredColumnReaderOptions& opts) : _opts(opts) {}
~OptionalStoredColumnReader() = default;
~OptionalStoredColumnReader() override = default;
Status init(const ParquetField* field, const tparquet::ColumnChunk* chunk_metadata, RandomAccessFile* file) {
_field = field;
@ -93,7 +93,7 @@ public:
}
}
void set_needs_levels(bool needs_levels) { _needs_levels = needs_levels; }
void set_needs_levels(bool needs_levels) override { _needs_levels = needs_levels; }
void get_levels(level_t** def_levels, level_t** rep_levels, size_t* num_levels) override {
// _needs_levels must be true
@ -150,7 +150,7 @@ public:
Status read_records(size_t* num_rows, ColumnContentType content_type, vectorized::Column* dst) override;
void get_levels(level_t** def_levels, level_t** rep_levels, size_t* num_levels) {
void get_levels(level_t** def_levels, level_t** rep_levels, size_t* num_levels) override {
*def_levels = nullptr;
*rep_levels = nullptr;
*num_levels = 0;

2
be/src/exec/parquet_reader.h
View File

@ -55,7 +55,7 @@ class FileReader;
class ParquetFile : public arrow::io::RandomAccessFile {
public:
ParquetFile(FileReader* file);
virtual ~ParquetFile();
~ParquetFile() override;
arrow::Result<int64_t> Read(int64_t nbytes, void* buffer) override;
arrow::Result<int64_t> ReadAt(int64_t position, int64_t nbytes, void* out) override;
arrow::Result<int64_t> GetSize() override;

2
be/src/exec/parquet_writer.h
View File

@ -54,7 +54,7 @@ class RowBatch;
class ParquetOutputStream : public arrow::io::OutputStream {
public:
ParquetOutputStream(FileWriter* file_writer);
virtual ~ParquetOutputStream();
~ParquetOutputStream() override;
arrow::Status Write(const void* data, int64_t nbytes) override;
// return the current write position of the stream

2
be/src/exec/pipeline/aggregate/aggregate_blocking_sink_operator.h
View File

@ -12,7 +12,7 @@ public:
: Operator(id, "aggregate_blocking_sink", plan_node_id), _aggregator(aggregator) {
_aggregator->set_aggr_phase(AggrPhase2);
}
~AggregateBlockingSinkOperator() = default;
~AggregateBlockingSinkOperator() override = default;
bool has_output() const override { return false; }
bool need_input() const override { return true; }

2
be/src/exec/pipeline/aggregate/aggregate_blocking_source_operator.h
View File

@ -10,7 +10,7 @@ class AggregateBlockingSourceOperator : public SourceOperator {
public:
AggregateBlockingSourceOperator(int32_t id, int32_t plan_node_id, AggregatorPtr aggregator)
: SourceOperator(id, "aggregate_blocking_source", plan_node_id), _aggregator(aggregator) {}
~AggregateBlockingSourceOperator() = default;
~AggregateBlockingSourceOperator() override = default;
bool has_output() const override;
bool is_finished() const override;

2
be/src/exec/pipeline/aggregate/aggregate_distinct_blocking_sink_operator.h
View File

@ -12,7 +12,7 @@ public:
: Operator(id, "aggregate_distinct_blocking_sink", plan_node_id), _aggregator(aggregator) {
_aggregator->set_aggr_phase(AggrPhase2);
}
~AggregateDistinctBlockingSinkOperator() = default;
~AggregateDistinctBlockingSinkOperator() override = default;
bool has_output() const override { return false; }
bool need_input() const override { return true; }

2
be/src/exec/pipeline/aggregate/aggregate_distinct_blocking_source_operator.h
View File

@ -10,7 +10,7 @@ class AggregateDistinctBlockingSourceOperator : public SourceOperator {
public:
AggregateDistinctBlockingSourceOperator(int32_t id, int32_t plan_node_id, AggregatorPtr aggregator)
: SourceOperator(id, "aggregate_distinct_blocking_source", plan_node_id), _aggregator(aggregator) {}
~AggregateDistinctBlockingSourceOperator() = default;
~AggregateDistinctBlockingSourceOperator() override = default;
bool has_output() const override;
bool is_finished() const override;

2
be/src/exec/pipeline/aggregate/aggregate_distinct_streaming_sink_operator.h
View File

@ -12,7 +12,7 @@ public:
: Operator(id, "aggregate_distinct_streaming_sink", plan_node_id), _aggregator(aggregator) {
_aggregator->set_aggr_phase(AggrPhase1);
}
~AggregateDistinctStreamingSinkOperator() = default;
~AggregateDistinctStreamingSinkOperator() override = default;
bool has_output() const override { return false; }
bool need_input() const override { return true; }

2
be/src/exec/pipeline/aggregate/aggregate_distinct_streaming_source_operator.h
View File

@ -10,7 +10,7 @@ class AggregateDistinctStreamingSourceOperator : public SourceOperator {
public:
AggregateDistinctStreamingSourceOperator(int32_t id, int32_t plan_node_id, AggregatorPtr aggregator)
: SourceOperator(id, "aggregate_distinct_streaming_source", plan_node_id), _aggregator(aggregator) {}
~AggregateDistinctStreamingSourceOperator() = default;
~AggregateDistinctStreamingSourceOperator() override = default;
bool has_output() const override;
bool is_finished() const override;

2
be/src/exec/pipeline/aggregate/aggregate_streaming_sink_operator.h
View File

@ -12,7 +12,7 @@ public:
: Operator(id, "aggregate_streaming_sink", plan_node_id), _aggregator(aggregator) {
_aggregator->set_aggr_phase(AggrPhase1);
}
~AggregateStreamingSinkOperator() = default;
~AggregateStreamingSinkOperator() override = default;
bool has_output() const override { return false; }
bool need_input() const override { return true; }

2
be/src/exec/pipeline/aggregate/aggregate_streaming_source_operator.h
View File

@ -10,7 +10,7 @@ class AggregateStreamingSourceOperator : public SourceOperator {
public:
AggregateStreamingSourceOperator(int32_t id, int32_t plan_node_id, AggregatorPtr aggregator)
: SourceOperator(id, "aggregate_streaming_source", plan_node_id), _aggregator(aggregator) {}
~AggregateStreamingSourceOperator() = default;
~AggregateStreamingSourceOperator() override = default;
bool has_output() const override;
bool is_finished() const override;

2
be/src/exec/pipeline/pipeline_driver_queue.h
View File

@ -54,7 +54,7 @@ public:
static const size_t QUEUE_SIZE = 8;
// maybe other value for ratio.
static constexpr double RATIO_OF_ADJACENT_QUEUE = 1.7;
void put_back(const DriverPtr& driver);
void put_back(const DriverPtr& driver) override;
DriverPtr take(size_t* queue_index) override;
SubQuerySharedDriverQueue* get_sub_queue(size_t) override;

2
be/src/exec/pipeline/sort/sort_sink_operator.h
View File

@ -50,7 +50,7 @@ public:
Status push_chunk(RuntimeState* state, const vectorized::ChunkPtr& chunk) override;
virtual void finish(RuntimeState* state) override;
void finish(RuntimeState* state) override;
private:
// This method is the same as topn node.

2
be/src/exec/pipeline/sort/sort_source_operator.h
View File

@ -34,7 +34,7 @@ public:
void add_morsel(Morsel* morsel) {}
virtual void finish(RuntimeState* state) override;
void finish(RuntimeState* state) override;
private:
std::shared_ptr<vectorized::ChunksSorter> _chunks_sorter;

6
be/src/exec/plain_text_line_reader.h
View File

@ -39,11 +39,11 @@ public:
PlainTextLineReader(RuntimeProfile* profile, FileReader* file_reader, Decompressor* decompressor, size_t length,
uint8_t row_delimiter);
virtual ~PlainTextLineReader();
~PlainTextLineReader() override;
virtual Status read_line(const uint8_t** ptr, size_t* size, bool* eof) override;
Status read_line(const uint8_t** ptr, size_t* size, bool* eof) override;
virtual void close() override;
void close() override;
private:
bool update_eof();

6
be/src/exec/scan_node.h
View File

@ -85,16 +85,16 @@ class TScanRange;
class ScanNode : public ExecNode {
public:
ScanNode(ObjectPool* pool, const TPlanNode& tnode, const DescriptorTbl& descs) : ExecNode(pool, tnode, descs) {}
virtual ~ScanNode() {}
~ScanNode() override {}
// Set up counters
virtual Status prepare(RuntimeState* state);
Status prepare(RuntimeState* state) override;
// Convert scan_ranges into node-specific scan restrictions. This should be
// called after prepare()
virtual Status set_scan_ranges(const std::vector<TScanRangeParams>& scan_ranges) = 0;
virtual bool is_scan_node() const { return true; }
bool is_scan_node() const override { return true; }
RuntimeProfile::Counter* bytes_read_counter() const { return _bytes_read_counter; }
RuntimeProfile::Counter* rows_read_counter() const { return _rows_read_counter; }

6
be/src/exec/select_node.h
View File

@ -37,10 +37,10 @@ class SelectNode : public ExecNode {
public:
SelectNode(ObjectPool* pool, const TPlanNode& tnode, const DescriptorTbl& descs);
virtual Status prepare(RuntimeState* state);
virtual Status open(RuntimeState* state);
Status prepare(RuntimeState* state) override;
Status open(RuntimeState* state) override;
Status get_next(RuntimeState* state, ChunkPtr* chunk, bool* eos) override;
virtual Status close(RuntimeState* state);
Status close(RuntimeState* state) override;
private:
// true if last get_next() call on child signalled eos

2
be/src/exec/tablet_sink.h
View File

@ -87,7 +87,7 @@ template <typename T>
class ReusableClosure : public google::protobuf::Closure {
public:
ReusableClosure() : cid(INVALID_BTHREAD_ID) {}
~ReusableClosure() {
~ReusableClosure() override {
// shouldn't delete when Run() is calling or going to be called, wait for current Run() done.
join();
}

2
be/src/exec/vectorized/analytic_node.h
View File

@ -26,7 +26,7 @@ struct FrameRange {
class AnalyticNode : public ExecNode {
public:
~AnalyticNode() {}
~AnalyticNode() override {}
AnalyticNode(ObjectPool* pool, const TPlanNode& tnode, const DescriptorTbl& descs);
Status init(const TPlanNode& tnode, RuntimeState* state = nullptr) override;

2
be/src/exec/vectorized/assert_num_rows_node.h
View File

@ -24,7 +24,7 @@ namespace starrocks::vectorized {
class AssertNumRowsNode : public ExecNode {
public:
AssertNumRowsNode(ObjectPool* pool, const TPlanNode& tnode, const DescriptorTbl& descs);
virtual ~AssertNumRowsNode(){};
~AssertNumRowsNode() override{};
Status init(const TPlanNode& tnode, RuntimeState* state = nullptr) override;
Status prepare(RuntimeState* state) override;

2
be/src/exec/vectorized/es_http_scan_node.h
View File

@ -20,7 +20,7 @@ namespace vectorized {
class EsHttpScanNode final : public starrocks::ScanNode {
public:
EsHttpScanNode(ObjectPool* pool, const TPlanNode& tnode, const DescriptorTbl& descs);
~EsHttpScanNode();
~EsHttpScanNode() override;
Status init(const TPlanNode& tnode, RuntimeState* state = nullptr) override;
Status prepare(RuntimeState* state) override;

2
be/src/exec/vectorized/hdfs_scanner.h
View File

@ -177,7 +177,7 @@ protected:
class HdfsParquetScanner final : public HdfsScanner {
public:
HdfsParquetScanner() = default;
virtual ~HdfsParquetScanner() = default;
~HdfsParquetScanner() override = default;
void update_counter();
Status do_open(RuntimeState* runtime_state) override;

6
be/src/exec/vectorized/hdfs_scanner_orc.cpp
View File

@ -52,11 +52,11 @@ public:
const std::map<uint32_t, orc::BloomFilterIndex>& bloomFilters) override;
bool filterMinMax(size_t rowGroupIdx, const std::unordered_map<uint64_t, orc::proto::RowIndex>& rowIndexes,
const std::map<uint32_t, orc::BloomFilterIndex>& bloomFilter);
bool filterOnPickStringDictionary(const std::unordered_map<uint64_t, orc::StringDictionary*>& sdicts);
bool filterOnPickStringDictionary(const std::unordered_map<uint64_t, orc::StringDictionary*>& sdicts) override;
bool is_slot_evaluated(SlotId id) { return _dict_filter_eval_cache.find(id) != _dict_filter_eval_cache.end(); }
virtual void onStartingPickRowGroups() override;
virtual void onEndingPickRowGroups() override;
void onStartingPickRowGroups() override;
void onEndingPickRowGroups() override;
private:
const HdfsScannerParams& _scanner_params;

2
be/src/exec/vectorized/hdfs_scanner_orc.h
View File

@ -14,7 +14,7 @@ class OrcRowReaderFilter;
class HdfsOrcScanner final : public HdfsScanner {
public:
HdfsOrcScanner() = default;
virtual ~HdfsOrcScanner() = default;
~HdfsOrcScanner() override = default;
void update_counter();
Status do_open(RuntimeState* runtime_state) override;

2
be/src/exec/vectorized/json_scanner.h
View File

@ -28,7 +28,7 @@ class JsonScanner : public FileScanner {
public:
JsonScanner(RuntimeState* state, RuntimeProfile* profile, const TBrokerScanRange& scan_range,
ScannerCounter* counter);
~JsonScanner();
~JsonScanner() override;
// Open this scanner, will initialize information needed
Status open() override;

2
be/src/exec/vectorized/parquet_reader.h
View File

@ -32,7 +32,7 @@ using RecordBatchPtr = std::shared_ptr<RecordBatch>;
class ParquetChunkFile : public arrow::io::RandomAccessFile {
public:
ParquetChunkFile(std::shared_ptr<starrocks::RandomAccessFile> file, uint64_t pos);
virtual ~ParquetChunkFile();
~ParquetChunkFile() override;
arrow::Result<int64_t> Read(int64_t nbytes, void* buffer) override;
arrow::Result<int64_t> ReadAt(int64_t position, int64_t nbytes, void* out) override;
arrow::Result<int64_t> GetSize() override;

2
be/src/exec/vectorized/parquet_scanner.h
View File

@ -32,7 +32,7 @@ public:
ParquetScanner(RuntimeState* state, RuntimeProfile* profile, const TBrokerScanRange& scan_range,
ScannerCounter* counter);
~ParquetScanner();
~ParquetScanner() override;
Status open() override;

2
be/src/exec/vectorized/schema_scan_node.h
View File

@ -19,7 +19,7 @@ namespace starrocks::vectorized {
class SchemaScanNode : public ScanNode {
public:
SchemaScanNode(ObjectPool* pool, const TPlanNode& tnode, const DescriptorTbl& descs);
~SchemaScanNode();
~SchemaScanNode() override;
// Prepare conjuncts, create Schema columns to slots mapping
// initialize _schema_scanner

4
be/src/exec/vectorized/schema_scanner/schema_charsets_scanner.h
View File

@ -12,9 +12,9 @@ namespace starrocks::vectorized {
class SchemaCharsetsScanner : public SchemaScanner {
public:
SchemaCharsetsScanner();
virtual ~SchemaCharsetsScanner();
~SchemaCharsetsScanner() override;
virtual Status get_next(ChunkPtr* chunk, bool* eos);
Status get_next(ChunkPtr* chunk, bool* eos) override;
private:
struct CharsetStruct {

4
be/src/exec/vectorized/schema_scanner/schema_collations_scanner.h
View File

@ -12,9 +12,9 @@ namespace starrocks::vectorized {
class SchemaCollationsScanner : public SchemaScanner {
public:
SchemaCollationsScanner();
virtual ~SchemaCollationsScanner();
~SchemaCollationsScanner() override;
virtual Status get_next(ChunkPtr* chunk, bool* eos);
Status get_next(ChunkPtr* chunk, bool* eos) override;
private:
struct CollationStruct {

6
be/src/exec/vectorized/schema_scanner/schema_columns_scanner.h
View File

@ -12,9 +12,9 @@ namespace starrocks::vectorized {
class SchemaColumnsScanner : public SchemaScanner {
public:
SchemaColumnsScanner();
virtual ~SchemaColumnsScanner();
virtual Status start(RuntimeState* state);
virtual Status get_next(ChunkPtr* chunk, bool* eos);
~SchemaColumnsScanner() override;
Status start(RuntimeState* state) override;
Status get_next(ChunkPtr* chunk, bool* eos) override;
std::string to_mysql_data_type_string(TColumnDesc& desc);
std::string type_to_string(TColumnDesc& desc);

4
be/src/exec/vectorized/schema_scanner/schema_dummy_scanner.h
View File

@ -10,9 +10,9 @@ namespace starrocks::vectorized {
class SchemaDummyScanner : public SchemaScanner {
public:
SchemaDummyScanner();
virtual ~SchemaDummyScanner();
~SchemaDummyScanner() override;
virtual Status start();
virtual Status get_next(ChunkPtr* chunk, bool* eos);
Status get_next(ChunkPtr* chunk, bool* eos) override;
private:
static SchemaScanner::ColumnDesc _s_dummy_columns[];

2
be/src/exec/vectorized/schema_scanner/schema_events_scanner.h
View File

@ -10,7 +10,7 @@ namespace starrocks::vectorized {
class SchemaEventsScanner : public SchemaScanner {
public:
SchemaEventsScanner();
virtual ~SchemaEventsScanner();
~SchemaEventsScanner() override;
private:
static SchemaScanner::ColumnDesc _s_cols_events[];

2
be/src/exec/vectorized/schema_scanner/schema_schema_privileges_scanner.h
View File

@ -12,7 +12,7 @@ namespace starrocks::vectorized {
class SchemaSchemaPrivilegesScanner : public SchemaScanner {
public:
SchemaSchemaPrivilegesScanner();
virtual ~SchemaSchemaPrivilegesScanner();
~SchemaSchemaPrivilegesScanner() override;
Status start(RuntimeState* state) override;
Status get_next(ChunkPtr* chunk, bool* eos) override;

6
be/src/exec/vectorized/schema_scanner/schema_schemata_scanner.h
View File

@ -10,10 +10,10 @@ namespace starrocks::vectorized {
class SchemaSchemataScanner : public SchemaScanner {
public:
SchemaSchemataScanner();
virtual ~SchemaSchemataScanner();
~SchemaSchemataScanner() override;
virtual Status start(RuntimeState* state);
virtual Status get_next(ChunkPtr* chunk, bool* eos);
Status start(RuntimeState* state) override;
Status get_next(ChunkPtr* chunk, bool* eos) override;
private:
Status fill_chunk(ChunkPtr* chunk);

2
be/src/exec/vectorized/schema_scanner/schema_statistics_scanner.h
View File

@ -10,7 +10,7 @@ namespace starrocks::vectorized {
class SchemaStatisticsScanner : public SchemaScanner {
public:
SchemaStatisticsScanner();
virtual ~SchemaStatisticsScanner();
~SchemaStatisticsScanner() override;
private:
static SchemaScanner::ColumnDesc _s_cols_statistics[];

2
be/src/exec/vectorized/schema_scanner/schema_table_privileges_scanner.h
View File

@ -12,7 +12,7 @@ namespace starrocks::vectorized {
class SchemaTablePrivilegesScanner : public SchemaScanner {
public:
SchemaTablePrivilegesScanner();
virtual ~SchemaTablePrivilegesScanner();
~SchemaTablePrivilegesScanner() override;
Status start(RuntimeState* state) override;
Status get_next(ChunkPtr* chunk, bool* eos) override;

6
be/src/exec/vectorized/schema_scanner/schema_tables_scanner.h
View File

@ -10,10 +10,10 @@ namespace starrocks::vectorized {
class SchemaTablesScanner : public SchemaScanner {
public:
SchemaTablesScanner();
virtual ~SchemaTablesScanner();
~SchemaTablesScanner() override;
virtual Status start(RuntimeState* state);
virtual Status get_next(ChunkPtr* chunk, bool* eos);
Status start(RuntimeState* state) override;
Status get_next(ChunkPtr* chunk, bool* eos) override;
private:
Status get_new_table();

2
be/src/exec/vectorized/schema_scanner/schema_triggers_scanner.h
View File

@ -10,7 +10,7 @@ namespace starrocks::vectorized {
class SchemaTriggersScanner : public SchemaScanner {
public:
SchemaTriggersScanner();
virtual ~SchemaTriggersScanner();
~SchemaTriggersScanner() override;
private:
static SchemaScanner::ColumnDesc _s_cols_triggers[];

2
be/src/exec/vectorized/schema_scanner/schema_user_privileges_scanner.h
View File

@ -12,7 +12,7 @@ namespace starrocks::vectorized {
class SchemaUserPrivilegesScanner : public SchemaScanner {
public:
SchemaUserPrivilegesScanner();
virtual ~SchemaUserPrivilegesScanner();
~SchemaUserPrivilegesScanner() override;
Status start(RuntimeState* state) override;
Status get_next(ChunkPtr* chunk, bool* eos) override;

6
be/src/exec/vectorized/schema_scanner/schema_variables_scanner.h
View File

@ -13,10 +13,10 @@ namespace starrocks::vectorized {
class SchemaVariablesScanner : public SchemaScanner {
public:
SchemaVariablesScanner(TVarType::type type);
virtual ~SchemaVariablesScanner();
~SchemaVariablesScanner() override;
virtual Status start(RuntimeState* state);
virtual Status get_next(ChunkPtr* chunk, bool* eos);
Status start(RuntimeState* state) override;
Status get_next(ChunkPtr* chunk, bool* eos) override;
private:
Status fill_chunk(ChunkPtr* chunk);

2
be/src/exec/vectorized/schema_scanner/schema_views_scanner.h
View File

@ -10,7 +10,7 @@ namespace starrocks::vectorized {
class SchemaViewsScanner : public SchemaScanner {
public:
SchemaViewsScanner();
virtual ~SchemaViewsScanner();
~SchemaViewsScanner() override;
Status start(RuntimeState* state) override;
Status get_next(ChunkPtr* chunk, bool* eos) override;

2
be/src/exec/vectorized/topn_node.h
View File

@ -16,7 +16,7 @@ class ChunksSorter;
class TopNNode final : public ::starrocks::ExecNode {
public:
TopNNode(ObjectPool* pool, const TPlanNode& tnode, const DescriptorTbl& descs);
virtual ~TopNNode();
~TopNNode() override;
// overridden methods defined in ::starrocks::ExecNode
Status init(const TPlanNode& tnode, RuntimeState* state = nullptr) override;

2
be/src/exprs/agg/avg.h
View File

@ -168,7 +168,7 @@ public:
column->append(result);
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
ResultColumnType* column = down_cast<ResultColumnType*>(dst);

4
be/src/exprs/agg/count.h
View File

@ -41,7 +41,7 @@ public:
data(state).count += input_column->get_data()[row_num];
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
Int64Column* column = down_cast<Int64Column*>(dst);
for (size_t i = start; i < end; ++i) {
@ -134,7 +134,7 @@ public:
data(state).count += input_column->get_data()[row_num];
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
Int64Column* column = down_cast<Int64Column*>(dst);
for (size_t i = start; i < end; ++i) {

2
be/src/exprs/agg/hll_ndv.h
View File

@ -78,7 +78,7 @@ public:
this->data(state).merge(hll);
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
Int64Column* column = down_cast<Int64Column*>(dst);
int64_t result = this->data(state).estimate_cardinality();

2
be/src/exprs/agg/hll_union_count.h
View File

@ -43,7 +43,7 @@ public:
this->data(state).merge(*(hll_column->get_object(row_num)));
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
Int64Column* column = down_cast<Int64Column*>(dst);
int64_t result = this->data(state).estimate_cardinality();

4
be/src/exprs/agg/maxmin.h
View File

@ -215,7 +215,7 @@ public:
down_cast<InputColumnType*>(to)->append(this->data(state).result);
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
InputColumnType* column = down_cast<InputColumnType*>(dst);
for (size_t i = start; i < end; ++i) {
@ -270,7 +270,7 @@ public:
column->append(this->data(state).slice());
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
BinaryColumn* column = down_cast<BinaryColumn*>(dst);
for (size_t i = start; i < end; ++i) {

2
be/src/exprs/agg/nullable_aggregate.h
View File

@ -105,7 +105,7 @@ public:
}
void batch_finalize(FunctionContext* ctx, size_t batch_size, const Buffer<AggDataPtr>& agg_states,
size_t state_offset, Column* to) const {
size_t state_offset, Column* to) const override {
for (size_t i = 0; i < batch_size; i++) {
finalize_to_column(ctx, agg_states[i] + state_offset, to);
}

2
be/src/exprs/agg/sum.h
View File

@ -74,7 +74,7 @@ public:
this->data(state).sum += input_column->get_data()[row_num];
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
ResultType result = this->data(state).sum;
ResultColumnType* column = down_cast<ResultColumnType*>(dst);

4
be/src/exprs/agg/variance.h
View File

@ -233,7 +233,7 @@ public:
}
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
TResult result;
@ -359,7 +359,7 @@ public:
}
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
TResult result;

20
be/src/exprs/agg/window.h
View File

@ -56,7 +56,7 @@ class WindowFunction : public AggregateFunctionStateHelper<State> {
}
void batch_finalize(FunctionContext* ctx, size_t batch_size, const Buffer<AggDataPtr>& agg_states,
size_t state_offset, Column* to) const {
size_t state_offset, Column* to) const override {
DCHECK(false) << "Shouldn't call this method for window function!";
}
@ -129,7 +129,7 @@ class RowNumberWindowFunction final : public WindowFunction<RowNumberState> {
this->data(state).cur_positon++;
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
Int64Column* column = down_cast<Int64Column*>(dst);
column->get_data()[start] = this->data(state).cur_positon;
@ -162,7 +162,7 @@ class RankWindowFunction final : public WindowFunction<RankState> {
this->data(state).count = peer_group_count;
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
Int64Column* column = down_cast<Int64Column*>(dst);
for (size_t i = start; i < end; ++i) {
@ -193,7 +193,7 @@ class DenseRankWindowFunction final : public WindowFunction<DenseRankState> {
}
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
DCHECK_GT(end, start);
Int64Column* column = down_cast<Int64Column*>(dst);
for (size_t i = start; i < end; ++i) {
@ -241,7 +241,7 @@ class FirstValueWindowFunction final : public ValueWindowFunction<PT, FirstValue
this->data(state).has_value = true;
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
this->get_values_helper(state, dst, start, end);
}
@ -278,7 +278,7 @@ class LastValueWindowFunction final : public ValueWindowFunction<PT, LastValueSt
this->data(state).value = column->get_data()[frame_end - 1];
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
this->get_values_helper(state, dst, start, end);
}
@ -336,7 +336,7 @@ class LeadLagWindowFunction final : public ValueWindowFunction<PT, LeadLagState<
this->data(state).value = column->get_data()[frame_end - 1];
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
this->get_values_helper(state, dst, start, end);
}
@ -381,7 +381,7 @@ class FirstValueWindowFunction<PT, Slice, BinaryPTGuard<PT>> final : public Wind
this->data(state).has_value = true;
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
this->get_slice_values(state, dst, start, end);
}
@ -420,7 +420,7 @@ class LastValueWindowFunction<PT, Slice, BinaryPTGuard<PT>> final : public Windo
this->data(state).buffer.insert(this->data(state).buffer.end(), p, p + slice.size);
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
this->get_slice_values(state, dst, start, end);
}
@ -481,7 +481,7 @@ class LeadLagWindowFunction<PT, Slice, BinaryPTGuard<PT>> final : public WindowF
this->data(state).value.insert(this->data(state).value.end(), p, p + slice.size);
}
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const {
void get_values(FunctionContext* ctx, ConstAggDataPtr state, Column* dst, size_t start, size_t end) const override {
this->get_slice_values(state, dst, start, end);
}

38
be/src/exprs/slot_ref.h
View File

@ -40,7 +40,7 @@ class SlotRef final : public Expr {
public:
SlotRef(const TExprNode& node);
SlotRef(const SlotDescriptor* desc);
virtual Expr* clone(ObjectPool* pool) const override { return pool->add(new SlotRef(*this)); }
Expr* clone(ObjectPool* pool) const override { return pool->add(new SlotRef(*this)); }
// TODO: this is a hack to allow aggregation nodes to work around NULL slot
// descriptors. Ideally the FE would dictate the type of the intermediate SlotRefs.
@ -51,34 +51,34 @@ public:
Status prepare(const SlotDescriptor* slot_desc, const RowDescriptor& row_desc);
virtual Status prepare(RuntimeState* state, const RowDescriptor& row_desc, ExprContext* ctx);
Status prepare(RuntimeState* state, const RowDescriptor& row_desc, ExprContext* ctx) override;
static void* get_value(Expr* expr, TupleRow* row);
void* get_slot(TupleRow* row);
Tuple* get_tuple(TupleRow* row);
bool is_null_bit_set(TupleRow* row);
static bool vector_compute_fn(Expr* expr, VectorizedRowBatch* batch);
static bool is_nullable(Expr* expr);
virtual std::string debug_string() const;
virtual bool is_constant() const { return false; }
virtual bool is_vectorized() const { return true; }
virtual bool is_bound(const std::vector<TupleId>& tuple_ids) const;
virtual int get_slot_ids(std::vector<SlotId>* slot_ids) const;
std::string debug_string() const override;
bool is_constant() const override { return false; }
bool is_vectorized() const override { return true; }
bool is_bound(const std::vector<TupleId>& tuple_ids) const override;
int get_slot_ids(std::vector<SlotId>* slot_ids) const override;
SlotId slot_id() const { return _slot_id; }
TupleId tuple_id() const { return _tuple_id; }
inline NullIndicatorOffset null_indicator_offset() const { return _null_indicator_offset; }
virtual starrocks_udf::BooleanVal get_boolean_val(ExprContext* context, TupleRow*);
virtual starrocks_udf::TinyIntVal get_tiny_int_val(ExprContext* context, TupleRow*);
virtual starrocks_udf::SmallIntVal get_small_int_val(ExprContext* context, TupleRow*);
virtual starrocks_udf::IntVal get_int_val(ExprContext* context, TupleRow*);
virtual starrocks_udf::BigIntVal get_big_int_val(ExprContext* context, TupleRow*);
virtual starrocks_udf::LargeIntVal get_large_int_val(ExprContext* context, TupleRow*);
virtual starrocks_udf::FloatVal get_float_val(ExprContext* context, TupleRow*);
virtual starrocks_udf::DoubleVal get_double_val(ExprContext* context, TupleRow*);
virtual starrocks_udf::StringVal get_string_val(ExprContext* context, TupleRow*);
virtual starrocks_udf::DateTimeVal get_datetime_val(ExprContext* context, TupleRow*);
virtual starrocks_udf::DecimalVal get_decimal_val(ExprContext* context, TupleRow*);
virtual starrocks_udf::DecimalV2Val get_decimalv2_val(ExprContext* context, TupleRow*);
starrocks_udf::BooleanVal get_boolean_val(ExprContext* context, TupleRow*) override;
starrocks_udf::TinyIntVal get_tiny_int_val(ExprContext* context, TupleRow*) override;
starrocks_udf::SmallIntVal get_small_int_val(ExprContext* context, TupleRow*) override;
starrocks_udf::IntVal get_int_val(ExprContext* context, TupleRow*) override;
starrocks_udf::BigIntVal get_big_int_val(ExprContext* context, TupleRow*) override;
starrocks_udf::LargeIntVal get_large_int_val(ExprContext* context, TupleRow*) override;
starrocks_udf::FloatVal get_float_val(ExprContext* context, TupleRow*) override;
starrocks_udf::DoubleVal get_double_val(ExprContext* context, TupleRow*) override;
starrocks_udf::StringVal get_string_val(ExprContext* context, TupleRow*) override;
starrocks_udf::DateTimeVal get_datetime_val(ExprContext* context, TupleRow*) override;
starrocks_udf::DecimalVal get_decimal_val(ExprContext* context, TupleRow*) override;
starrocks_udf::DecimalV2Val get_decimalv2_val(ExprContext* context, TupleRow*) override;
// virtual starrocks_udf::ArrayVal GetArrayVal(ExprContext* context, TupleRow*);
// vector query engine

2
be/src/exprs/vectorized/arithmetic_expr.cpp
View File

@ -35,7 +35,7 @@ public:
return VectorizedStrictBinaryFunction<ArithmeticOp>::template evaluate<Type>(l, r);
}
}
std::string debug_string() const {
std::string debug_string() const override {
std::stringstream out;
auto expr_debug_string = Expr::debug_string();
out << "VectorizedArithmeticExpr ("

2
be/src/exprs/vectorized/cast_expr.cpp
View File

@ -655,7 +655,7 @@ public:
return cast_fn<FromType, ToType>(column);
}
};
std::string debug_string() const {
std::string debug_string() const override {
std::stringstream out;
auto expr_debug_string = Expr::debug_string();
out << "VectorizedCastExpr ("

2
be/src/exprs/vectorized/column_ref.h
View File

@ -24,7 +24,7 @@ public:
// FixMe(kks): currenly, join runtime filter need this method
// we should find a way remove this method
bool is_bound(const std::vector<TupleId>& tuple_ids) const;
bool is_bound(const std::vector<TupleId>& tuple_ids) const override;
Expr* clone(ObjectPool* pool) const override { return pool->add(new ColumnRef(*this)); }

4
be/src/exprs/vectorized/in_const_predicate.hpp
View File

@ -44,9 +44,9 @@ public:
VectorizedInConstPredicate(const VectorizedInConstPredicate& other)
: Predicate(other), _is_not_in(other._is_not_in), _null_in_set(false) {}
~VectorizedInConstPredicate() {}
~VectorizedInConstPredicate() override {}
virtual Expr* clone(ObjectPool* pool) const override { return pool->add(new VectorizedInConstPredicate(*this)); }
Expr* clone(ObjectPool* pool) const override { return pool->add(new VectorizedInConstPredicate(*this)); }
Status prepare([[maybe_unused]] RuntimeState* state) {
if (_is_prepare) {

4
be/src/exprs/vectorized/in_iterator_predicate.hpp
View File

@ -22,9 +22,9 @@ public:
VectorizedInIteratorPredicate(const VectorizedInIteratorPredicate& other)
: Predicate(other), _is_not_in(other._is_not_in) {}
~VectorizedInIteratorPredicate() {}
~VectorizedInIteratorPredicate() override {}
virtual Expr* clone(ObjectPool* pool) const override {
Expr* clone(ObjectPool* pool) const override {
return pool->add(new VectorizedInIteratorPredicate(*this));
}

4
be/src/exprs/vectorized/info_func.h
View File

@ -12,9 +12,9 @@ class VectorizedInfoFunc final : public Expr {
public:
VectorizedInfoFunc(const TExprNode& node);
virtual ~VectorizedInfoFunc();
~VectorizedInfoFunc() override;
virtual Expr* clone(ObjectPool* pool) const override { return pool->add(new VectorizedInfoFunc(*this)); }
Expr* clone(ObjectPool* pool) const override { return pool->add(new VectorizedInfoFunc(*this)); }
ColumnPtr evaluate(ExprContext* context, vectorized::Chunk* ptr) override;

4
be/src/exprs/vectorized/literal.h
View File

@ -11,9 +11,9 @@ class VectorizedLiteral final : public Expr {
public:
VectorizedLiteral(const TExprNode& node);
virtual ~VectorizedLiteral();
~VectorizedLiteral() override;
virtual Expr* clone(ObjectPool* pool) const override { return pool->add(new VectorizedLiteral(*this)); }
Expr* clone(ObjectPool* pool) const override { return pool->add(new VectorizedLiteral(*this)); }
ColumnPtr evaluate(ExprContext* context, vectorized::Chunk* ptr) override;

6
be/src/exprs/vectorized/runtime_filter.h
View File

@ -231,9 +231,9 @@ public:
using ColumnType = RunTimeColumnType<Type>;
RuntimeBloomFilter() = default;
~RuntimeBloomFilter() = default;
~RuntimeBloomFilter() override = default;
virtual RuntimeBloomFilter* create_empty(ObjectPool* pool) override { return pool->add(new RuntimeBloomFilter()); };
RuntimeBloomFilter* create_empty(ObjectPool* pool) override { return pool->add(new RuntimeBloomFilter()); };
void init_min_max() {
_has_min_max = false;
@ -566,7 +566,7 @@ public:
return offset;
}
virtual bool check_equal(const JoinRuntimeFilter& base_rf) const override {
bool check_equal(const JoinRuntimeFilter& base_rf) const override {
if (!JoinRuntimeFilter::check_equal(base_rf)) return false;
const auto& rf = static_cast<const RuntimeBloomFilter<Type>&>(base_rf);
if constexpr (!IsSlice<CppType>) {

6
be/src/formats/orc/apache-orc/c++/include/orc/Exceptions.hh
View File

@ -34,7 +34,7 @@ class NotImplementedYet : public std::logic_error {
public:
explicit NotImplementedYet(const std::string& what_arg);
explicit NotImplementedYet(const char* what_arg);
virtual ~NotImplementedYet() ORC_NOEXCEPT;
~NotImplementedYet() ORC_NOEXCEPT override;
NotImplementedYet(const NotImplementedYet&);
private:
@ -45,7 +45,7 @@ class ParseError : public std::runtime_error {
public:
explicit ParseError(const std::string& what_arg);
explicit ParseError(const char* what_arg);
virtual ~ParseError() ORC_NOEXCEPT;
~ParseError() ORC_NOEXCEPT override;
ParseError(const ParseError&);
private:
@ -56,7 +56,7 @@ class InvalidArgument : public std::runtime_error {
public:
explicit InvalidArgument(const std::string& what_arg);
explicit InvalidArgument(const char* what_arg);
virtual ~InvalidArgument() ORC_NOEXCEPT;
~InvalidArgument() ORC_NOEXCEPT override;
InvalidArgument(const InvalidArgument&);
private:

18
be/src/formats/orc/apache-orc/c++/include/orc/Statistics.hh
View File

@ -60,7 +60,7 @@ public:
*/
class BinaryColumnStatistics : public ColumnStatistics {
public:
virtual ~BinaryColumnStatistics();
~BinaryColumnStatistics() override;
/**
* Check whether column has total length.
@ -76,7 +76,7 @@ public:
*/
class BooleanColumnStatistics : public ColumnStatistics {
public:
virtual ~BooleanColumnStatistics();
~BooleanColumnStatistics() override;
/**
* Check whether column has true/false count.
@ -93,7 +93,7 @@ public:
*/
class DateColumnStatistics : public ColumnStatistics {
public:
virtual ~DateColumnStatistics();
~DateColumnStatistics() override;
/**
* Check whether column has minimum.
@ -125,7 +125,7 @@ public:
*/
class DecimalColumnStatistics : public ColumnStatistics {
public:
virtual ~DecimalColumnStatistics();
~DecimalColumnStatistics() override;
/**
* Check whether column has minimum.
@ -169,7 +169,7 @@ public:
*/
class DoubleColumnStatistics : public ColumnStatistics {
public:
virtual ~DoubleColumnStatistics();
~DoubleColumnStatistics() override;
/**
* Check whether column has minimum.
@ -216,7 +216,7 @@ public:
*/
class IntegerColumnStatistics : public ColumnStatistics {
public:
virtual ~IntegerColumnStatistics();
~IntegerColumnStatistics() override;
/**
* Check whether column has minimum.
@ -262,7 +262,7 @@ public:
*/
class StringColumnStatistics : public ColumnStatistics {
public:
virtual ~StringColumnStatistics();
~StringColumnStatistics() override;
/**
* Check whether column has minimum.
@ -306,7 +306,7 @@ public:
*/
class TimestampColumnStatistics : public ColumnStatistics {
public:
virtual ~TimestampColumnStatistics();
~TimestampColumnStatistics() override;
/**
* Check whether minimum timestamp exists.
@ -389,7 +389,7 @@ public:
class StripeStatistics : public Statistics {
public:
virtual ~StripeStatistics();
~StripeStatistics() override;
/**
* Get the statistics of a given RowIndex entry in a given column.

136
be/src/formats/orc/apache-orc/c++/include/orc/Vector.hh
View File

@ -100,35 +100,35 @@ private:
struct LongVectorBatch : public ColumnVectorBatch {
LongVectorBatch(uint64_t capacity, MemoryPool& pool);
virtual ~LongVectorBatch();
~LongVectorBatch() override;
DataBuffer<int64_t> data;
std::string toString() const;
void resize(uint64_t capacity);
void clear();
uint64_t getMemoryUsage();
virtual void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
std::string toString() const override;
void resize(uint64_t capacity) override;
void clear() override;
uint64_t getMemoryUsage() override;
void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
};
struct DoubleVectorBatch : public ColumnVectorBatch {
DoubleVectorBatch(uint64_t capacity, MemoryPool& pool);
virtual ~DoubleVectorBatch();
std::string toString() const;
void resize(uint64_t capacity);
void clear();
uint64_t getMemoryUsage();
~DoubleVectorBatch() override;
std::string toString() const override;
void resize(uint64_t capacity) override;
void clear() override;
uint64_t getMemoryUsage() override;
DataBuffer<double> data;
virtual void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
};
struct StringVectorBatch : public ColumnVectorBatch {
StringVectorBatch(uint64_t capacity, MemoryPool& pool);
virtual ~StringVectorBatch();
std::string toString() const;
void resize(uint64_t capacity);
void clear();
uint64_t getMemoryUsage();
~StringVectorBatch() override;
std::string toString() const override;
void resize(uint64_t capacity) override;
void clear() override;
uint64_t getMemoryUsage() override;
// pointers to the start of each string
DataBuffer<char*> data;
@ -139,7 +139,7 @@ struct StringVectorBatch : public ColumnVectorBatch {
// dict codes, iff. there is dictionary.
DataBuffer<int64_t> codes;
bool use_codes;
virtual void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
};
struct StringDictionary {
@ -168,37 +168,37 @@ struct StringDictionary {
*/
struct EncodedStringVectorBatch : public StringVectorBatch {
EncodedStringVectorBatch(uint64_t capacity, MemoryPool& pool);
virtual ~EncodedStringVectorBatch();
std::string toString() const;
void resize(uint64_t capacity);
~EncodedStringVectorBatch() override;
std::string toString() const override;
void resize(uint64_t capacity) override;
std::shared_ptr<StringDictionary> dictionary;
// index for dictionary entry
DataBuffer<int64_t> index;
virtual void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
};
struct StructVectorBatch : public ColumnVectorBatch {
StructVectorBatch(uint64_t capacity, MemoryPool& pool);
virtual ~StructVectorBatch();
std::string toString() const;
void resize(uint64_t capacity);
void clear();
uint64_t getMemoryUsage();
bool hasVariableLength();
~StructVectorBatch() override;
std::string toString() const override;
void resize(uint64_t capacity) override;
void clear() override;
uint64_t getMemoryUsage() override;
bool hasVariableLength() override;
std::vector<ColumnVectorBatch*> fields;
virtual void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
};
struct ListVectorBatch : public ColumnVectorBatch {
ListVectorBatch(uint64_t capacity, MemoryPool& pool);
virtual ~ListVectorBatch();
std::string toString() const;
void resize(uint64_t capacity);
void clear();
uint64_t getMemoryUsage();
bool hasVariableLength();
~ListVectorBatch() override;
std::string toString() const override;
void resize(uint64_t capacity) override;
void clear() override;
uint64_t getMemoryUsage() override;
bool hasVariableLength() override;
/**
* The offset of the first element of each list.
@ -208,17 +208,17 @@ struct ListVectorBatch : public ColumnVectorBatch {
// the concatenated elements
ORC_UNIQUE_PTR<ColumnVectorBatch> elements;
virtual void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
};
struct MapVectorBatch : public ColumnVectorBatch {
MapVectorBatch(uint64_t capacity, MemoryPool& pool);
virtual ~MapVectorBatch();
std::string toString() const;
void resize(uint64_t capacity);
void clear();
uint64_t getMemoryUsage();
bool hasVariableLength();
~MapVectorBatch() override;
std::string toString() const override;
void resize(uint64_t capacity) override;
void clear() override;
uint64_t getMemoryUsage() override;
bool hasVariableLength() override;
/**
* The offset of the first element of each map.
@ -230,17 +230,17 @@ struct MapVectorBatch : public ColumnVectorBatch {
ORC_UNIQUE_PTR<ColumnVectorBatch> keys;
// the concatenated elements
ORC_UNIQUE_PTR<ColumnVectorBatch> elements;
virtual void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
};
struct UnionVectorBatch : public ColumnVectorBatch {
UnionVectorBatch(uint64_t capacity, MemoryPool& pool);
virtual ~UnionVectorBatch();
std::string toString() const;
void resize(uint64_t capacity);
void clear();
uint64_t getMemoryUsage();
bool hasVariableLength();
~UnionVectorBatch() override;
std::string toString() const override;
void resize(uint64_t capacity) override;
void clear() override;
uint64_t getMemoryUsage() override;
bool hasVariableLength() override;
/**
* For each value, which element of children has the value.
@ -254,7 +254,7 @@ struct UnionVectorBatch : public ColumnVectorBatch {
// the sub-columns
std::vector<ColumnVectorBatch*> children;
virtual void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
};
struct Decimal {
@ -269,11 +269,11 @@ struct Decimal {
struct Decimal64VectorBatch : public ColumnVectorBatch {
Decimal64VectorBatch(uint64_t capacity, MemoryPool& pool);
virtual ~Decimal64VectorBatch();
std::string toString() const;
void resize(uint64_t capacity);
void clear();
uint64_t getMemoryUsage();
~Decimal64VectorBatch() override;
std::string toString() const override;
void resize(uint64_t capacity) override;
void clear() override;
uint64_t getMemoryUsage() override;
// total number of digits
int32_t precision;
@ -282,7 +282,7 @@ struct Decimal64VectorBatch : public ColumnVectorBatch {
// the numeric values
DataBuffer<int64_t> values;
virtual void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
protected:
/**
@ -296,11 +296,11 @@ protected:
struct Decimal128VectorBatch : public ColumnVectorBatch {
Decimal128VectorBatch(uint64_t capacity, MemoryPool& pool);
virtual ~Decimal128VectorBatch();
std::string toString() const;
void resize(uint64_t capacity);
void clear();
uint64_t getMemoryUsage();
~Decimal128VectorBatch() override;
std::string toString() const override;
void resize(uint64_t capacity) override;
void clear() override;
uint64_t getMemoryUsage() override;
// total number of digits
int32_t precision;
@ -309,7 +309,7 @@ struct Decimal128VectorBatch : public ColumnVectorBatch {
// the numeric values
DataBuffer<Int128> values;
virtual void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
protected:
/**
@ -329,11 +329,11 @@ protected:
*/
struct TimestampVectorBatch : public ColumnVectorBatch {
TimestampVectorBatch(uint64_t capacity, MemoryPool& pool);
virtual ~TimestampVectorBatch();
std::string toString() const;
void resize(uint64_t capacity);
void clear();
uint64_t getMemoryUsage();
~TimestampVectorBatch() override;
std::string toString() const override;
void resize(uint64_t capacity) override;
void clear() override;
uint64_t getMemoryUsage() override;
// the number of seconds past 1 Jan 1970 00:00 UTC (aka time_t)
// Note that we always assume data is in GMT timezone; therefore it is
@ -344,7 +344,7 @@ struct TimestampVectorBatch : public ColumnVectorBatch {
// the nanoseconds of each value
DataBuffer<int64_t> nanoseconds;
virtual void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
void filter(uint8_t* f_data, uint32_t f_size, uint32_t true_size) override;
};
} // namespace orc

34
be/src/formats/orc/apache-orc/c++/src/ByteRLE.cc
View File

@ -43,7 +43,7 @@ ByteRleEncoder::~ByteRleEncoder() {
class ByteRleEncoderImpl : public ByteRleEncoder {
public:
ByteRleEncoderImpl(std::unique_ptr<BufferedOutputStream> output);
virtual ~ByteRleEncoderImpl() override;
~ByteRleEncoderImpl() override;
/**
* Encode the next batch of values.
@ -52,19 +52,19 @@ public:
* @param notNull If the pointer is null, all values are read. If the
* pointer is not null, positions that are false are skipped.
*/
virtual void add(const char* data, uint64_t numValues, const char* notNull) override;
void add(const char* data, uint64_t numValues, const char* notNull) override;
/**
* Get size of buffer used so far.
*/
virtual uint64_t getBufferSize() const override;
uint64_t getBufferSize() const override;
/**
* Flush underlying BufferedOutputStream.
*/
virtual uint64_t flush() override;
uint64_t flush() override;
virtual void recordPosition(PositionRecorder* recorder) const override;
void recordPosition(PositionRecorder* recorder) const override;
protected:
std::unique_ptr<BufferedOutputStream> outputStream;
@ -209,7 +209,7 @@ std::unique_ptr<ByteRleEncoder> createByteRleEncoder(std::unique_ptr<BufferedOut
class BooleanRleEncoderImpl : public ByteRleEncoderImpl {
public:
BooleanRleEncoderImpl(std::unique_ptr<BufferedOutputStream> output);
virtual ~BooleanRleEncoderImpl() override;
~BooleanRleEncoderImpl() override;
/**
* Encode the next batch of values
@ -218,14 +218,14 @@ public:
* @param notNull If the pointer is null, all values are read. If the
* pointer is not null, positions that are false are skipped.
*/
virtual void add(const char* data, uint64_t numValues, const char* notNull) override;
void add(const char* data, uint64_t numValues, const char* notNull) override;
/**
* Flushing underlying BufferedOutputStream
*/
virtual uint64_t flush() override;
uint64_t flush() override;
virtual void recordPosition(PositionRecorder* recorder) const override;
void recordPosition(PositionRecorder* recorder) const override;
private:
int bitsRemained;
@ -290,22 +290,22 @@ class ByteRleDecoderImpl : public ByteRleDecoder {
public:
ByteRleDecoderImpl(std::unique_ptr<SeekableInputStream> input);
virtual ~ByteRleDecoderImpl();
~ByteRleDecoderImpl() override;
/**
* Seek to a particular spot.
*/
virtual void seek(PositionProvider&);
void seek(PositionProvider&) override;
/**
* Seek over a given number of values.
*/
virtual void skip(uint64_t numValues);
void skip(uint64_t numValues) override;
/**
* Read a number of values into the batch.
*/
virtual void next(char* data, uint64_t numValues, char* notNull);
void next(char* data, uint64_t numValues, char* notNull) override;
protected:
inline void nextBuffer();
@ -465,22 +465,22 @@ class BooleanRleDecoderImpl : public ByteRleDecoderImpl {
public:
BooleanRleDecoderImpl(std::unique_ptr<SeekableInputStream> input);
virtual ~BooleanRleDecoderImpl();
~BooleanRleDecoderImpl() override;
/**
* Seek to a particular spot.
*/
virtual void seek(PositionProvider&);
void seek(PositionProvider&) override;
/**
* Seek over a given number of values.
*/
virtual void skip(uint64_t numValues);
void skip(uint64_t numValues) override;
/**
* Read a number of values into the batch.
*/
virtual void next(char* data, uint64_t numValues, char* notNull);
void next(char* data, uint64_t numValues, char* notNull) override;
protected:
size_t remainingBits;

10
be/src/formats/orc/apache-orc/c++/src/ColumnPrinter.cc
View File

@ -75,7 +75,7 @@ private:
public:
DoubleColumnPrinter(std::string&, const Type& type);
virtual ~DoubleColumnPrinter() override {}
~DoubleColumnPrinter() override {}
void printRow(uint64_t rowId) override;
void reset(const ColumnVectorBatch& batch) override;
};
@ -134,7 +134,7 @@ private:
public:
StringColumnPrinter(std::string&);
virtual ~StringColumnPrinter() override {}
~StringColumnPrinter() override {}
void printRow(uint64_t rowId) override;
void reset(const ColumnVectorBatch& batch) override;
};
@ -146,7 +146,7 @@ private:
public:
BinaryColumnPrinter(std::string&);
virtual ~BinaryColumnPrinter() override {}
~BinaryColumnPrinter() override {}
void printRow(uint64_t rowId) override;
void reset(const ColumnVectorBatch& batch) override;
};
@ -158,7 +158,7 @@ private:
public:
ListColumnPrinter(std::string&, const Type& type);
virtual ~ListColumnPrinter() override {}
~ListColumnPrinter() override {}
void printRow(uint64_t rowId) override;
void reset(const ColumnVectorBatch& batch) override;
};
@ -171,7 +171,7 @@ private:
public:
MapColumnPrinter(std::string&, const Type& type);
virtual ~MapColumnPrinter() override {}
~MapColumnPrinter() override {}
void printRow(uint64_t rowId) override;
void reset(const ColumnVectorBatch& batch) override;
};

206
be/src/formats/orc/apache-orc/c++/src/ColumnWriter.cc
View File

@ -39,7 +39,7 @@ public:
StreamsFactoryImpl(const WriterOptions& writerOptions, OutputStream* outputStream)
: options(writerOptions), outStream(outputStream) {}
virtual std::unique_ptr<BufferedOutputStream> createStream(proto::Stream_Kind kind) const override;
std::unique_ptr<BufferedOutputStream> createStream(proto::Stream_Kind kind) const override;
private:
const WriterOptions& options;
@ -224,29 +224,28 @@ class StructColumnWriter : public ColumnWriter {
public:
StructColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options);
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
virtual void flush(std::vector<proto::Stream>& streams) override;
void flush(std::vector<proto::Stream>& streams) override;
virtual uint64_t getEstimatedSize() const override;
virtual void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
uint64_t getEstimatedSize() const override;
void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
virtual void getStripeStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
void getStripeStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
virtual void getFileStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
void getFileStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
virtual void mergeStripeStatsIntoFileStats() override;
void mergeStripeStatsIntoFileStats() override;
virtual void mergeRowGroupStatsIntoStripeStats() override;
void mergeRowGroupStatsIntoStripeStats() override;
virtual void createRowIndexEntry() override;
void createRowIndexEntry() override;
virtual void writeIndex(std::vector<proto::Stream>& streams) const override;
void writeIndex(std::vector<proto::Stream>& streams) const override;
virtual void writeDictionary() override;
void writeDictionary() override;
virtual void reset() override;
void reset() override;
private:
std::vector<std::unique_ptr<ColumnWriter>> children;
@ -384,16 +383,15 @@ class IntegerColumnWriter : public ColumnWriter {
public:
IntegerColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options);
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
virtual void flush(std::vector<proto::Stream>& streams) override;
void flush(std::vector<proto::Stream>& streams) override;
virtual uint64_t getEstimatedSize() const override;
uint64_t getEstimatedSize() const override;
virtual void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
virtual void recordPosition() const override;
void recordPosition() const override;
protected:
std::unique_ptr<RleEncoder> rleEncoder;
@ -482,16 +480,15 @@ class ByteColumnWriter : public ColumnWriter {
public:
ByteColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options);
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
virtual void flush(std::vector<proto::Stream>& streams) override;
void flush(std::vector<proto::Stream>& streams) override;
virtual uint64_t getEstimatedSize() const override;
uint64_t getEstimatedSize() const override;
virtual void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
virtual void recordPosition() const override;
void recordPosition() const override;
private:
std::unique_ptr<ByteRleEncoder> byteRleEncoder;
@ -579,16 +576,15 @@ class BooleanColumnWriter : public ColumnWriter {
public:
BooleanColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options);
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
virtual void flush(std::vector<proto::Stream>& streams) override;
void flush(std::vector<proto::Stream>& streams) override;
virtual uint64_t getEstimatedSize() const override;
uint64_t getEstimatedSize() const override;
virtual void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
virtual void recordPosition() const override;
void recordPosition() const override;
private:
std::unique_ptr<ByteRleEncoder> rleEncoder;
@ -677,16 +673,15 @@ class DoubleColumnWriter : public ColumnWriter {
public:
DoubleColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options, bool isFloat);
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
virtual void flush(std::vector<proto::Stream>& streams) override;
void flush(std::vector<proto::Stream>& streams) override;
virtual uint64_t getEstimatedSize() const override;
uint64_t getEstimatedSize() const override;
virtual void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
virtual void recordPosition() const override;
void recordPosition() const override;
private:
bool isFloat;
@ -917,22 +912,21 @@ class StringColumnWriter : public ColumnWriter {
public:
StringColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options);
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
virtual void flush(std::vector<proto::Stream>& streams) override;
void flush(std::vector<proto::Stream>& streams) override;
virtual uint64_t getEstimatedSize() const override;
uint64_t getEstimatedSize() const override;
virtual void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
virtual void recordPosition() const override;
void recordPosition() const override;
virtual void createRowIndexEntry() override;
void createRowIndexEntry() override;
virtual void writeDictionary() override;
void writeDictionary() override;
virtual void reset() override;
void reset() override;
private:
/**
@ -1328,8 +1322,7 @@ public:
padBuffer.resize(maxLength * 6);
}
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
private:
uint64_t maxLength;
@ -1402,8 +1395,7 @@ public:
// PASS
}
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
private:
uint64_t maxLength;
@ -1465,8 +1457,7 @@ public:
// PASS
}
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
};
void BinaryColumnWriter::add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
@ -1512,16 +1503,15 @@ public:
TimestampColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options,
bool isInstantType);
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
virtual void flush(std::vector<proto::Stream>& streams) override;
void flush(std::vector<proto::Stream>& streams) override;
virtual uint64_t getEstimatedSize() const override;
uint64_t getEstimatedSize() const override;
virtual void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
virtual void recordPosition() const override;
void recordPosition() const override;
protected:
std::unique_ptr<RleEncoder> secRleEncoder, nanoRleEncoder;
@ -1662,8 +1652,7 @@ class DateColumnWriter : public IntegerColumnWriter {
public:
DateColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options);
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
};
DateColumnWriter::DateColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options)
@ -1712,16 +1701,15 @@ public:
Decimal64ColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options);
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
virtual void flush(std::vector<proto::Stream>& streams) override;
void flush(std::vector<proto::Stream>& streams) override;
virtual uint64_t getEstimatedSize() const override;
uint64_t getEstimatedSize() const override;
virtual void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
virtual void recordPosition() const override;
void recordPosition() const override;
protected:
RleVersion rleVersion;
@ -1841,8 +1829,7 @@ class Decimal128ColumnWriter : public Decimal64ColumnWriter {
public:
Decimal128ColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options);
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
private:
char buffer[20];
@ -1923,32 +1910,31 @@ public:
ListColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options);
~ListColumnWriter() override;
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
virtual void flush(std::vector<proto::Stream>& streams) override;
void flush(std::vector<proto::Stream>& streams) override;
virtual uint64_t getEstimatedSize() const override;
uint64_t getEstimatedSize() const override;
virtual void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
virtual void getStripeStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
void getStripeStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
virtual void getFileStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
void getFileStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
virtual void mergeStripeStatsIntoFileStats() override;
void mergeStripeStatsIntoFileStats() override;
virtual void mergeRowGroupStatsIntoStripeStats() override;
void mergeRowGroupStatsIntoStripeStats() override;
virtual void createRowIndexEntry() override;
void createRowIndexEntry() override;
virtual void writeIndex(std::vector<proto::Stream>& streams) const override;
void writeIndex(std::vector<proto::Stream>& streams) const override;
virtual void recordPosition() const override;
void recordPosition() const override;
virtual void writeDictionary() override;
void writeDictionary() override;
virtual void reset() override;
void reset() override;
private:
std::unique_ptr<RleEncoder> lengthEncoder;
@ -2122,32 +2108,31 @@ public:
MapColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options);
~MapColumnWriter() override;
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
virtual void flush(std::vector<proto::Stream>& streams) override;
void flush(std::vector<proto::Stream>& streams) override;
virtual uint64_t getEstimatedSize() const override;
uint64_t getEstimatedSize() const override;
virtual void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
virtual void getStripeStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
void getStripeStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
virtual void getFileStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
void getFileStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
virtual void mergeStripeStatsIntoFileStats() override;
void mergeStripeStatsIntoFileStats() override;
virtual void mergeRowGroupStatsIntoStripeStats() override;
void mergeRowGroupStatsIntoStripeStats() override;
virtual void createRowIndexEntry() override;
void createRowIndexEntry() override;
virtual void writeIndex(std::vector<proto::Stream>& streams) const override;
void writeIndex(std::vector<proto::Stream>& streams) const override;
virtual void recordPosition() const override;
void recordPosition() const override;
virtual void writeDictionary() override;
void writeDictionary() override;
virtual void reset() override;
void reset() override;
private:
std::unique_ptr<ColumnWriter> keyWriter;
@ -2362,32 +2347,31 @@ class UnionColumnWriter : public ColumnWriter {
public:
UnionColumnWriter(const Type& type, const StreamsFactory& factory, const WriterOptions& options);
virtual void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues,
const char* incomingMask) override;
void add(ColumnVectorBatch& rowBatch, uint64_t offset, uint64_t numValues, const char* incomingMask) override;
virtual void flush(std::vector<proto::Stream>& streams) override;
void flush(std::vector<proto::Stream>& streams) override;
virtual uint64_t getEstimatedSize() const override;
uint64_t getEstimatedSize() const override;
virtual void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
void getColumnEncoding(std::vector<proto::ColumnEncoding>& encodings) const override;
virtual void getStripeStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
void getStripeStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
virtual void getFileStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
void getFileStatistics(std::vector<proto::ColumnStatistics>& stats) const override;
virtual void mergeStripeStatsIntoFileStats() override;
void mergeStripeStatsIntoFileStats() override;
virtual void mergeRowGroupStatsIntoStripeStats() override;
void mergeRowGroupStatsIntoStripeStats() override;
virtual void createRowIndexEntry() override;
void createRowIndexEntry() override;
virtual void writeIndex(std::vector<proto::Stream>& streams) const override;
void writeIndex(std::vector<proto::Stream>& streams) const override;
virtual void recordPosition() const override;
void recordPosition() const override;
virtual void writeDictionary() override;
void writeDictionary() override;
virtual void reset() override;
void reset() override;
private:
std::unique_ptr<ByteRleEncoder> rleEncoder;

4
be/src/formats/orc/apache-orc/c++/src/ColumnWriter.hh
View File

@ -52,11 +52,11 @@ std::unique_ptr<StreamsFactory> createStreamsFactory(const WriterOptions& option
*/
class RowIndexPositionRecorder : public PositionRecorder {
public:
virtual ~RowIndexPositionRecorder() override;
~RowIndexPositionRecorder() override;
RowIndexPositionRecorder(proto::RowIndexEntry& entry) : rowIndexEntry(entry) {}
virtual void add(uint64_t pos) override { rowIndexEntry.add_positions(pos); }
void add(uint64_t pos) override { rowIndexEntry.add_positions(pos); }
private:
proto::RowIndexEntry& rowIndexEntry;

82
be/src/formats/orc/apache-orc/c++/src/Compression.cc
View File

@ -55,14 +55,14 @@ public:
CompressionStreamBase(OutputStream* outStream, int compressionLevel, uint64_t capacity, uint64_t blockSize,
MemoryPool& pool);
virtual bool Next(void** data, int* size) override = 0;
virtual void BackUp(int count) override;
bool Next(void** data, int* size) override = 0;
void BackUp(int count) override;
virtual std::string getName() const override = 0;
virtual uint64_t flush() override;
std::string getName() const override = 0;
uint64_t flush() override;
virtual bool isCompressed() const override { return true; }
virtual uint64_t getSize() const override;
bool isCompressed() const override { return true; }
uint64_t getSize() const override;
protected:
void writeHeader(char* buffer, size_t compressedSize, bool original) {
@ -148,8 +148,8 @@ public:
CompressionStream(OutputStream* outStream, int compressionLevel, uint64_t capacity, uint64_t blockSize,
MemoryPool& pool);
virtual bool Next(void** data, int* size) override;
virtual std::string getName() const override = 0;
bool Next(void** data, int* size) override;
std::string getName() const override = 0;
protected:
// return total compressed size
@ -194,12 +194,12 @@ public:
ZlibCompressionStream(OutputStream* outStream, int compressionLevel, uint64_t capacity, uint64_t blockSize,
MemoryPool& pool);
virtual ~ZlibCompressionStream() override { end(); }
~ZlibCompressionStream() override { end(); }
virtual std::string getName() const override;
std::string getName() const override;
protected:
virtual uint64_t doStreamingCompression() override;
uint64_t doStreamingCompression() override;
private:
void init();
@ -278,13 +278,13 @@ enum DecompressState { DECOMPRESS_HEADER, DECOMPRESS_START, DECOMPRESS_CONTINUE,
class DecompressionStream : public SeekableInputStream {
public:
DecompressionStream(std::unique_ptr<SeekableInputStream> inStream, size_t bufferSize, MemoryPool& pool);
virtual ~DecompressionStream() override {}
virtual bool Next(const void** data, int* size) override;
virtual void BackUp(int count) override;
virtual bool Skip(int count) override;
virtual int64_t ByteCount() const override;
virtual void seek(PositionProvider& position) override;
virtual std::string getName() const override = 0;
~DecompressionStream() override {}
bool Next(const void** data, int* size) override;
void BackUp(int count) override;
bool Skip(int count) override;
int64_t ByteCount() const override;
void seek(PositionProvider& position) override;
std::string getName() const override = 0;
protected:
virtual void NextDecompress(const void** data, int* size, size_t availableSize) = 0;
@ -522,11 +522,11 @@ void DecompressionStream::seek(PositionProvider& position) {
class ZlibDecompressionStream : public DecompressionStream {
public:
ZlibDecompressionStream(std::unique_ptr<SeekableInputStream> inStream, size_t blockSize, MemoryPool& pool);
virtual ~ZlibDecompressionStream() override;
virtual std::string getName() const override;
~ZlibDecompressionStream() override;
std::string getName() const override;
protected:
virtual void NextDecompress(const void** data, int* size, size_t availableSize) override;
void NextDecompress(const void** data, int* size, size_t availableSize) override;
private:
z_stream zstream;
@ -634,11 +634,11 @@ class BlockDecompressionStream : public DecompressionStream {
public:
BlockDecompressionStream(std::unique_ptr<SeekableInputStream> inStream, size_t blockSize, MemoryPool& pool);
virtual ~BlockDecompressionStream() override {}
virtual std::string getName() const override = 0;
~BlockDecompressionStream() override {}
std::string getName() const override = 0;
protected:
virtual void NextDecompress(const void** data, int* size, size_t availableSize) override;
void NextDecompress(const void** data, int* size, size_t availableSize) override;
virtual uint64_t decompress(const char* input, uint64_t length, char* output, size_t maxOutputLength) = 0;
@ -697,7 +697,7 @@ public:
}
protected:
virtual uint64_t decompress(const char* input, uint64_t length, char* output, size_t maxOutputLength) override;
uint64_t decompress(const char* input, uint64_t length, char* output, size_t maxOutputLength) override;
};
uint64_t SnappyDecompressionStream::decompress(const char* _input, uint64_t length, char* output,
@ -731,7 +731,7 @@ public:
}
protected:
virtual uint64_t decompress(const char* input, uint64_t length, char* output, size_t maxOutputLength) override;
uint64_t decompress(const char* input, uint64_t length, char* output, size_t maxOutputLength) override;
};
uint64_t LzoDecompressionStream::decompress(const char* inputPtr, uint64_t length, char* output,
@ -753,7 +753,7 @@ public:
}
protected:
virtual uint64_t decompress(const char* input, uint64_t length, char* output, size_t maxOutputLength) override;
uint64_t decompress(const char* input, uint64_t length, char* output, size_t maxOutputLength) override;
};
uint64_t Lz4DecompressionStream::decompress(const char* inputPtr, uint64_t length, char* output,
@ -776,8 +776,8 @@ public:
// PASS
}
virtual bool Next(void** data, int* size) override;
virtual std::string getName() const override = 0;
bool Next(void** data, int* size) override;
std::string getName() const override = 0;
protected:
// compresses a block and returns the compressed size
@ -854,16 +854,14 @@ public:
this->init();
}
virtual std::string getName() const override { return "Lz4CompressionStream"; }
std::string getName() const override { return "Lz4CompressionStream"; }
virtual ~Lz4CompressionSteam() override { this->end(); }
~Lz4CompressionSteam() override { this->end(); }
protected:
virtual uint64_t doBlockCompression() override;
uint64_t doBlockCompression() override;
virtual uint64_t estimateMaxCompressionSize() override {
return static_cast<uint64_t>(LZ4_compressBound(bufferSize));
}
uint64_t estimateMaxCompressionSize() override { return static_cast<uint64_t>(LZ4_compressBound(bufferSize)); }
private:
void init();
@ -905,16 +903,14 @@ public:
this->init();
}
virtual std::string getName() const override { return "ZstdCompressionStream"; }
std::string getName() const override { return "ZstdCompressionStream"; }
virtual ~ZSTDCompressionStream() override { this->end(); }
~ZSTDCompressionStream() override { this->end(); }
protected:
virtual uint64_t doBlockCompression() override;
uint64_t doBlockCompression() override;
virtual uint64_t estimateMaxCompressionSize() override {
return ZSTD_compressBound(static_cast<size_t>(bufferSize));
}
uint64_t estimateMaxCompressionSize() override { return ZSTD_compressBound(static_cast<size_t>(bufferSize)); }
private:
void init();
@ -957,7 +953,7 @@ public:
this->init();
}
virtual ~ZSTDDecompressionStream() override { this->end(); }
~ZSTDDecompressionStream() override { this->end(); }
std::string getName() const override {
std::ostringstream result;
@ -966,7 +962,7 @@ public:
}
protected:
virtual uint64_t decompress(const char* input, uint64_t length, char* output, size_t maxOutputLength) override;
uint64_t decompress(const char* input, uint64_t length, char* output, size_t maxOutputLength) override;
private:
void init();

2
be/src/formats/orc/apache-orc/c++/src/LzoDecompressor.cc
View File

@ -52,7 +52,7 @@ public:
MalformedInputException(const MalformedInputException& other) : ParseError(other.what()) {}
virtual ~MalformedInputException() noexcept;
~MalformedInputException() noexcept override;
};
MalformedInputException::~MalformedInputException() noexcept {

2
be/src/formats/orc/apache-orc/c++/src/MemoryPool.cc
View File

@ -39,7 +39,7 @@ MemoryPool::~MemoryPool() {
class MemoryPoolImpl : public MemoryPool {
public:
virtual ~MemoryPoolImpl() override;
~MemoryPoolImpl() override;
char* malloc(uint64_t size) override;
void free(char* p) override;

28
be/src/formats/orc/apache-orc/c++/src/Statistics.hh
View File

@ -208,7 +208,7 @@ private:
public:
ColumnStatisticsImpl() { reset(); }
ColumnStatisticsImpl(const proto::ColumnStatistics& stats);
virtual ~ColumnStatisticsImpl() override;
~ColumnStatisticsImpl() override;
uint64_t getNumberOfValues() const override { return _stats.getNumberOfValues(); }
@ -246,7 +246,7 @@ private:
public:
BinaryColumnStatisticsImpl() { reset(); }
BinaryColumnStatisticsImpl(const proto::ColumnStatistics& stats, const StatContext& statContext);
virtual ~BinaryColumnStatisticsImpl() override;
~BinaryColumnStatisticsImpl() override;
uint64_t getNumberOfValues() const override { return _stats.getNumberOfValues(); }
@ -316,7 +316,7 @@ private:
public:
BooleanColumnStatisticsImpl() { reset(); }
BooleanColumnStatisticsImpl(const proto::ColumnStatistics& stats, const StatContext& statContext);
virtual ~BooleanColumnStatisticsImpl() override;
~BooleanColumnStatisticsImpl() override;
bool hasCount() const override { return _hasCount; }
@ -406,7 +406,7 @@ private:
public:
DateColumnStatisticsImpl() { reset(); }
DateColumnStatisticsImpl(const proto::ColumnStatistics& stats, const StatContext& statContext);
virtual ~DateColumnStatisticsImpl() override;
~DateColumnStatisticsImpl() override;
bool hasMinimum() const override { return _stats.hasMinimum(); }
@ -498,7 +498,7 @@ private:
public:
DecimalColumnStatisticsImpl() { reset(); }
DecimalColumnStatisticsImpl(const proto::ColumnStatistics& stats, const StatContext& statContext);
virtual ~DecimalColumnStatisticsImpl() override;
~DecimalColumnStatisticsImpl() override;
bool hasMinimum() const override { return _stats.hasMinimum(); }
@ -660,7 +660,7 @@ private:
public:
DoubleColumnStatisticsImpl() { reset(); }
DoubleColumnStatisticsImpl(const proto::ColumnStatistics& stats);
virtual ~DoubleColumnStatisticsImpl() override;
~DoubleColumnStatisticsImpl() override;
bool hasMinimum() const override { return _stats.hasMinimum(); }
@ -789,7 +789,7 @@ private:
public:
IntegerColumnStatisticsImpl() { reset(); }
IntegerColumnStatisticsImpl(const proto::ColumnStatistics& stats);
virtual ~IntegerColumnStatisticsImpl() override;
~IntegerColumnStatisticsImpl() override;
bool hasMinimum() const override { return _stats.hasMinimum(); }
@ -921,7 +921,7 @@ private:
public:
StringColumnStatisticsImpl() { reset(); }
StringColumnStatisticsImpl(const proto::ColumnStatistics& stats, const StatContext& statContext);
virtual ~StringColumnStatisticsImpl() override;
~StringColumnStatisticsImpl() override;
bool hasMinimum() const override { return _stats.hasMinimum(); }
@ -1076,7 +1076,7 @@ private:
public:
TimestampColumnStatisticsImpl() { reset(); }
TimestampColumnStatisticsImpl(const proto::ColumnStatistics& stats, const StatContext& statContext);
virtual ~TimestampColumnStatisticsImpl() override;
~TimestampColumnStatisticsImpl() override;
bool hasMinimum() const override { return _stats.hasMinimum(); }
@ -1303,9 +1303,9 @@ public:
StatisticsImpl(const proto::Footer& footer, const StatContext& statContext);
virtual const ColumnStatistics* getColumnStatistics(uint32_t columnId) const override { return colStats[columnId]; }
const ColumnStatistics* getColumnStatistics(uint32_t columnId) const override { return colStats[columnId]; }
virtual ~StatisticsImpl() override;
~StatisticsImpl() override;
uint32_t getNumberOfColumns() const override { return static_cast<uint32_t>(colStats.size()); }
};
@ -1324,18 +1324,18 @@ public:
std::vector<std::vector<proto::ColumnStatistics> >& indexStats,
const StatContext& statContext);
virtual const ColumnStatistics* getColumnStatistics(uint32_t columnId) const override {
const ColumnStatistics* getColumnStatistics(uint32_t columnId) const override {
return columnStats->getColumnStatistics(columnId);
}
uint32_t getNumberOfColumns() const override { return columnStats->getNumberOfColumns(); }
virtual const ColumnStatistics* getRowIndexStatistics(uint32_t columnId, uint32_t rowIndex) const override {
const ColumnStatistics* getRowIndexStatistics(uint32_t columnId, uint32_t rowIndex) const override {
// check id indices are valid
return rowIndexStats[columnId][rowIndex].get();
}
virtual ~StripeStatisticsImpl() override;
~StripeStatisticsImpl() override;
uint32_t getNumberOfRowIndexStats(uint32_t columnId) const override {
return static_cast<uint32_t>(rowIndexStats[columnId].size());

12
be/src/formats/orc/apache-orc/c++/src/StripeStream.hh
View File

@ -53,14 +53,14 @@ public:
const proto::StripeFooter& footer, uint64_t stripeStart, InputStream& input,
const Timezone& writerTimezone, const Timezone& readerTimezone);
virtual ~StripeStreamsImpl() override;
~StripeStreamsImpl() override;
virtual const std::vector<bool> getSelectedColumns() const override;
const std::vector<bool> getSelectedColumns() const override;
virtual proto::ColumnEncoding getEncoding(uint64_t columnId) const override;
proto::ColumnEncoding getEncoding(uint64_t columnId) const override;
virtual std::unique_ptr<SeekableInputStream> getStream(uint64_t columnId, proto::Stream_Kind kind,
bool shouldStream) const override;
std::unique_ptr<SeekableInputStream> getStream(uint64_t columnId, proto::Stream_Kind kind,
bool shouldStream) const override;
MemoryPool& getMemoryPool() const override;
@ -143,7 +143,7 @@ public:
// PASS
}
virtual ~StripeInformationImpl() override {
~StripeInformationImpl() override {
// PASS
}

24
be/src/formats/orc/apache-orc/c++/src/Timezone.cc
View File

@ -231,7 +231,7 @@ class FutureRuleImpl : public FutureRule {
}
public:
virtual ~FutureRuleImpl() override;
~FutureRuleImpl() override;
bool isDefined() const override;
const TimezoneVariant& getVariant(int64_t clk) const override;
void print(std::ostream& out) const override;
@ -501,24 +501,24 @@ static uint32_t decode32(const unsigned char* ptr) {
class Version1Parser : public VersionParser {
public:
virtual ~Version1Parser() override;
~Version1Parser() override;
virtual uint64_t getVersion() const override { return 1; }
uint64_t getVersion() const override { return 1; }
/**
* Get the number of bytes
*/
virtual uint64_t getTimeSize() const override { return 4; }
uint64_t getTimeSize() const override { return 4; }
/**
* Parse the time at the given location.
*/
virtual int64_t parseTime(const unsigned char* ptr) const override {
int64_t parseTime(const unsigned char* ptr) const override {
// sign extend from 32 bits
return static_cast<int32_t>(decode32(ptr));
}
virtual std::string parseFutureString(const unsigned char*, uint64_t, uint64_t) const override { return ""; }
std::string parseFutureString(const unsigned char*, uint64_t, uint64_t) const override { return ""; }
};
Version1Parser::~Version1Parser() {
@ -527,23 +527,23 @@ Version1Parser::~Version1Parser() {
class Version2Parser : public VersionParser {
public:
virtual ~Version2Parser() override;
~Version2Parser() override;
virtual uint64_t getVersion() const override { return 2; }
uint64_t getVersion() const override { return 2; }
/**
* Get the number of bytes
*/
virtual uint64_t getTimeSize() const override { return 8; }
uint64_t getTimeSize() const override { return 8; }
/**
* Parse the time at the given location.
*/
virtual int64_t parseTime(const unsigned char* ptr) const override {
int64_t parseTime(const unsigned char* ptr) const override {
return static_cast<int64_t>(decode32(ptr)) << 32 | decode32(ptr + 4);
}
virtual std::string parseFutureString(const unsigned char* ptr, uint64_t offset, uint64_t length) const override {
std::string parseFutureString(const unsigned char* ptr, uint64_t offset, uint64_t length) const override {
return std::string(reinterpret_cast<const char*>(ptr) + offset + 1, length - 2);
}
};
@ -555,7 +555,7 @@ Version2Parser::~Version2Parser() {
class TimezoneImpl : public Timezone {
public:
TimezoneImpl(const std::string& name, const std::vector<unsigned char> bytes);
virtual ~TimezoneImpl() override;
~TimezoneImpl() override;
/**
* Get the variant for the given time (time_t).

2
be/src/formats/orc/apache-orc/c++/src/Timezone.hh
View File

@ -113,7 +113,7 @@ class TimezoneError : public std::runtime_error {
public:
TimezoneError(const std::string& what);
TimezoneError(const TimezoneError&);
virtual ~TimezoneError() ORC_NOEXCEPT;
~TimezoneError() ORC_NOEXCEPT override;
};
/**

30
be/src/formats/orc/apache-orc/c++/src/io/InputStream.hh
View File

@ -54,7 +54,7 @@ public:
*/
class SeekableInputStream : public google::protobuf::io::ZeroCopyInputStream {
public:
virtual ~SeekableInputStream();
~SeekableInputStream() override;
virtual void seek(PositionProvider& position) = 0;
virtual std::string getName() const = 0;
};
@ -72,13 +72,13 @@ private:
public:
SeekableArrayInputStream(const unsigned char* list, uint64_t length, uint64_t block_size = 0);
SeekableArrayInputStream(const char* list, uint64_t length, uint64_t block_size = 0);
virtual ~SeekableArrayInputStream() override;
virtual bool Next(const void** data, int* size) override;
virtual void BackUp(int count) override;
virtual bool Skip(int count) override;
virtual google::protobuf::int64 ByteCount() const override;
virtual void seek(PositionProvider& position) override;
virtual std::string getName() const override;
~SeekableArrayInputStream() override;
bool Next(const void** data, int* size) override;
void BackUp(int count) override;
bool Skip(int count) override;
google::protobuf::int64 ByteCount() const override;
void seek(PositionProvider& position) override;
std::string getName() const override;
};
/**
@ -98,14 +98,14 @@ private:
public:
SeekableFileInputStream(InputStream* input, uint64_t offset, uint64_t byteCount, MemoryPool& pool,
uint64_t blockSize = 0);
virtual ~SeekableFileInputStream() override;
~SeekableFileInputStream() override;
virtual bool Next(const void** data, int* size) override;
virtual void BackUp(int count) override;
virtual bool Skip(int count) override;
virtual int64_t ByteCount() const override;
virtual void seek(PositionProvider& position) override;
virtual std::string getName() const override;
bool Next(const void** data, int* size) override;
void BackUp(int count) override;
bool Skip(int count) override;
int64_t ByteCount() const override;
void seek(PositionProvider& position) override;
std::string getName() const override;
};
} // namespace orc

12
be/src/formats/orc/apache-orc/c++/src/io/OutputStream.hh
View File

@ -52,13 +52,13 @@ private:
public:
BufferedOutputStream(MemoryPool& pool, OutputStream* outStream, uint64_t capacity, uint64_t block_size);
virtual ~BufferedOutputStream() override;
~BufferedOutputStream() override;
virtual bool Next(void** data, int* size) override;
virtual void BackUp(int count) override;
virtual google::protobuf::int64 ByteCount() const override;
virtual bool WriteAliasedRaw(const void* data, int size) override;
virtual bool AllowsAliasing() const override;
bool Next(void** data, int* size) override;
void BackUp(int count) override;
google::protobuf::int64 ByteCount() const override;
bool WriteAliasedRaw(const void* data, int size) override;
bool AllowsAliasing() const override;
virtual std::string getName() const;
virtual uint64_t getSize() const;

2
be/src/geo/geo_types.h
View File

@ -137,7 +137,7 @@ private:
class GeoCircle : public GeoShape {
public:
GeoCircle();
~GeoCircle();
~GeoCircle() override;
GeoParseStatus init(double lng, double lat, double radius);

4
be/src/gutil/stl_util.h
View File

@ -437,7 +437,7 @@ class TemplatedElementDeleter : public BaseDeleter {
public:
explicit TemplatedElementDeleter<STLContainer>(STLContainer* ptr) : container_ptr_(ptr) {}
virtual ~TemplatedElementDeleter<STLContainer>() { STLDeleteElements(container_ptr_); }
~TemplatedElementDeleter<STLContainer>() override { STLDeleteElements(container_ptr_); }
private:
STLContainer* container_ptr_;
@ -469,7 +469,7 @@ class TemplatedValueDeleter : public BaseDeleter {
public:
explicit TemplatedValueDeleter<STLContainer>(STLContainer* ptr) : container_ptr_(ptr) {}
virtual ~TemplatedValueDeleter<STLContainer>() { STLDeleteValues(container_ptr_); }
~TemplatedValueDeleter<STLContainer>() override { STLDeleteValues(container_ptr_); }
private:
STLContainer* container_ptr_;

2
be/src/gutil/threading/thread_collision_warner.h
View File

@ -135,7 +135,7 @@ struct BASE_EXPORT AsserterBase {
};
struct BASE_EXPORT DCheckAsserter : public AsserterBase {
virtual ~DCheckAsserter() {}
~DCheckAsserter() override {}
void warn(int64_t previous_thread_id, int64_t current_thread_id) override;
};

2
be/src/http/action/checksum_action.h
View File

@ -34,7 +34,7 @@ class ChecksumAction : public HttpHandler {
public:
explicit ChecksumAction(ExecEnv* exec_env);
virtual ~ChecksumAction() {}
~ChecksumAction() override {}
void handle(HttpRequest* req) override;

2
be/src/http/action/compaction_action.h
View File

@ -34,7 +34,7 @@ class CompactionAction : public HttpHandler {
public:
CompactionAction(CompactionActionType type) : _type(type) {}
virtual ~CompactionAction() {}
~CompactionAction() override {}
void handle(HttpRequest* req) override;

2
be/src/http/action/health_action.h
View File

@ -33,7 +33,7 @@ class HealthAction : public HttpHandler {
public:
HealthAction(ExecEnv* exec_env);
virtual ~HealthAction(){};
~HealthAction() override{};
void handle(HttpRequest* req) override;

6
be/src/http/action/metrics_action.cpp
View File

@ -39,7 +39,7 @@ namespace starrocks {
class PrometheusMetricsVisitor : public MetricsVisitor {
public:
virtual ~PrometheusMetricsVisitor() {}
~PrometheusMetricsVisitor() override {}
void visit(const std::string& prefix, const std::string& name, MetricCollector* collector) override;
std::string to_string() const { return _ss.str(); }
@ -55,7 +55,7 @@ private:
// starrocks_be_process_thread_num LONG 240
class SimpleCoreMetricsVisitor : public MetricsVisitor {
public:
virtual ~SimpleCoreMetricsVisitor() {}
~SimpleCoreMetricsVisitor() override {}
void visit(const std::string& prefix, const std::string& name, MetricCollector* collector) override;
std::string to_string() const { return _ss.str(); }
@ -146,7 +146,7 @@ void SimpleCoreMetricsVisitor::visit(const std::string& prefix, const std::strin
class JsonMetricsVisitor : public MetricsVisitor {
public:
JsonMetricsVisitor() {}
virtual ~JsonMetricsVisitor() {}
~JsonMetricsVisitor() override {}
void visit(const std::string& prefix, const std::string& name, MetricCollector* collector) override;
std::string to_string() {
rapidjson::StringBuffer strBuf;

Some files were not shown because too many files have changed in this diff Show More