From b69bae9beb71349b10085eb955362d3801e83c7f Mon Sep 17 00:00:00 2001 From: longfar-ncy <77976092+longfar-ncy@users.noreply.github.com> Date: Mon, 17 Jul 2023 06:50:52 +0800 Subject: [PATCH] Narrowing convension (#1730) * fix: fix narrowing convension * fix: make codes better --------- Co-authored-by: longfar --- .clang-tidy | 7 +- include/pika_command.h | 9 +- include/pika_define.h | 2 +- include/pika_dispatch_thread.h | 2 +- include/pika_repl_client.h | 2 +- src/net/src/backend_thread.cc | 4 +- src/net/src/bg_thread.cc | 4 +- src/net/src/client_thread.cc | 4 +- src/net/src/holy_thread.cc | 4 +- src/net/src/http_conn.cc | 2 +- src/net/src/net_cli.cc | 6 +- src/net/src/net_pubsub.cc | 12 +-- src/net/src/pb_cli.cc | 10 +-- src/net/src/pb_conn.cc | 8 +- src/net/src/redis_cli.cc | 28 +++--- src/net/src/redis_conn.cc | 14 +-- src/net/src/redis_parser.cc | 6 +- src/net/src/server_thread.cc | 2 +- src/net/src/simple_http_conn.cc | 12 +-- src/net/src/worker_thread.cc | 6 +- src/pika.cc | 2 +- src/pika_admin.cc | 77 ++++++++-------- src/pika_binlog.cc | 12 +-- src/pika_binlog_transverter.cc | 2 +- src/pika_bit.cc | 8 +- src/pika_client_conn.cc | 8 +- src/pika_command.cc | 6 +- src/pika_conf.cc | 6 +- src/pika_consensus.cc | 8 +- src/pika_db.cc | 4 +- src/pika_dispatch_thread.cc | 2 +- src/pika_geo.cc | 20 ++--- src/pika_geohash.cc | 14 +-- src/pika_hash.cc | 34 +++---- src/pika_kv.cc | 129 ++++++++++++++------------- src/pika_list.cc | 18 ++-- src/pika_meta.cc | 2 +- src/pika_migrate_thread.cc | 22 ++--- src/pika_monitor_thread.cc | 8 +- src/pika_pubsub.cc | 8 +- src/pika_repl_bgworker.cc | 8 +- src/pika_repl_client.cc | 8 +- src/pika_repl_client_conn.cc | 2 +- src/pika_repl_server_conn.cc | 7 +- src/pika_rm.cc | 2 +- src/pika_server.cc | 40 ++++----- src/pika_set.cc | 30 +++---- src/pika_slave_node.cc | 2 +- src/pika_slot.cc | 6 +- src/pika_slot_command.cc | 36 ++++---- src/pika_stable_log.cc | 2 +- src/pika_zset.cc | 56 ++++++------ src/pstd/include/pstd_status.h | 2 +- src/pstd/src/base_conf.cc | 4 +- src/pstd/src/env.cc | 12 +-- src/pstd/src/posix.cc | 14 +-- src/pstd/src/pstd_hash.cc | 12 +-- src/pstd/src/pstd_string.cc | 21 ++--- src/storage/include/storage/util.h | 1 + src/storage/src/redis_hashes.cc | 10 +-- src/storage/src/redis_hyperloglog.cc | 10 +-- src/storage/src/redis_lists.cc | 22 ++--- src/storage/src/redis_sets.cc | 38 ++++---- src/storage/src/redis_strings.cc | 50 +++++------ src/storage/src/redis_zsets.cc | 22 ++--- src/storage/src/storage.cc | 20 ++--- src/storage/src/util.cc | 8 +- 67 files changed, 496 insertions(+), 483 deletions(-) diff --git a/.clang-tidy b/.clang-tidy index e4e2e7ed96..125b7fbe9f 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -5,16 +5,13 @@ Checks: ' google-*, modernize-*, performance-*, - -portability-*, + portability-*, -readability-*, + -cppcoreguidelines-*, -bugprone-easily-swappable-parameters, -bugprone-implicit-widening-of-multiplication-result, - -bugprone-narrowing-conversions, -bugprone-reserved-identifier, -bugprone-signed-char-misuse, - -bugprone-suspicious-include, - -bugprone-unhandled-self-assignment, - -bugprone-exception-escape, -bugprone-branch-clone, -clang-analyzer-cplusplus.NewDelete, -clang-analyzer-cplusplus.NewDeleteLeaks, diff --git a/include/pika_command.h b/include/pika_command.h index 5b9c09e374..1b0442f977 100644 --- a/include/pika_command.h +++ b/include/pika_command.h @@ -259,6 +259,9 @@ enum CmdFlags { void inline RedisAppendContent(std::string& str, const std::string& value); void inline RedisAppendLen(std::string& str, int64_t ori, const std::string& prefix); +void inline RedisAppendLenUint64(std::string& str, uint64_t ori, const std::string& prefix) { + RedisAppendLen(str, static_cast(ori), prefix); +} const std::string kNewLine = "\r\n"; @@ -378,11 +381,13 @@ class CmdRes { // Inline functions for Create Redis protocol void AppendStringLen(int64_t ori) { RedisAppendLen(message_, ori, "$"); } + void AppendStringLenUint64(uint64_t ori) { RedisAppendLenUint64(message_, ori, "$"); } void AppendArrayLen(int64_t ori) { RedisAppendLen(message_, ori, "*"); } + void AppendArrayLenUint64(uint64_t ori) { RedisAppendLenUint64(message_, ori, "*"); } void AppendInteger(int64_t ori) { RedisAppendLen(message_, ori, ":"); } void AppendContent(const std::string& value) { RedisAppendContent(message_, value); } void AppendString(const std::string& value) { - AppendStringLen(value.size()); + AppendStringLenUint64(value.size()); AppendContent(value); } void AppendStringRaw(const std::string& value) { message_.append(value); } @@ -473,7 +478,7 @@ class Cmd : public std::enable_shared_from_this { void InternalProcessCommand(const std::shared_ptr& slot, const std::shared_ptr& sync_slot, const HintKeys& hint_key); void DoCommand(const std::shared_ptr& slot, const HintKeys& hint_key); - bool CheckArg(int num) const; + bool CheckArg(uint64_t num) const; void LogCommand() const; std::string name_; diff --git a/include/pika_define.h b/include/pika_define.h index 2a09a995e8..a159a4e8cc 100644 --- a/include/pika_define.h +++ b/include/pika_define.h @@ -265,7 +265,7 @@ class RmNode : public Node { const std::string& DBName() const { return slot_info_.db_name_; } uint32_t SlotId() const { return slot_info_.slot_id_; } const SlotInfo& NodeSlotInfo() const { return slot_info_; } - void SetSessionId(uint32_t session_id) { session_id_ = session_id; } + void SetSessionId(int32_t session_id) { session_id_ = session_id; } int32_t SessionId() const { return session_id_; } std::string ToString() const { return "slot=" + DBName() + "_" + std::to_string(SlotId()) + ",ip_port=" + Ip() + ":" + diff --git a/include/pika_dispatch_thread.h b/include/pika_dispatch_thread.h index 14170bfe17..ac9f5a519c 100644 --- a/include/pika_dispatch_thread.h +++ b/include/pika_dispatch_thread.h @@ -15,7 +15,7 @@ class PikaDispatchThread { ~PikaDispatchThread(); int StartThread(); - int64_t ThreadClientList(std::vector* clients); + uint64_t ThreadClientList(std::vector* clients); bool ClientKill(const std::string& ip_port); void ClientKillAll(); diff --git a/include/pika_repl_client.h b/include/pika_repl_client.h index 5d43460e67..04a358d8d7 100644 --- a/include/pika_repl_client.h +++ b/include/pika_repl_client.h @@ -87,7 +87,7 @@ class PikaReplClient { private: size_t GetHashIndex(const std::string& key, bool upper_half); - void UpdateNextAvail() { next_avail_ = (next_avail_ + 1) % bg_workers_.size(); } + void UpdateNextAvail() { next_avail_ = (next_avail_ + 1) % static_cast(bg_workers_.size()); } std::unique_ptr client_thread_; int next_avail_ = 0; diff --git a/src/net/src/backend_thread.cc b/src/net/src/backend_thread.cc index ffd9fac9cb..b0eaa53687 100644 --- a/src/net/src/backend_thread.cc +++ b/src/net/src/backend_thread.cc @@ -311,7 +311,7 @@ void BackendThread::NotifyClose(const int fd) { void BackendThread::ProcessNotifyEvents(const NetFiredEvent* pfe) { if (pfe->mask & kReadable) { char bb[2048]; - int32_t nread = read(net_multiplexer_->NotifyReceiveFd(), bb, 2048); + int64_t nread = read(net_multiplexer_->NotifyReceiveFd(), bb, 2048); if (nread == 0) { return; } else { @@ -373,7 +373,7 @@ void* BackendThread::ThreadMain() { if (cron_interval_ > 0) { gettimeofday(&now, nullptr); if (when.tv_sec > now.tv_sec || (when.tv_sec == now.tv_sec && when.tv_usec > now.tv_usec)) { - timeout = (when.tv_sec - now.tv_sec) * 1000 + (when.tv_usec - now.tv_usec) / 1000; + timeout = static_cast((when.tv_sec - now.tv_sec) * 1000 + (when.tv_usec - now.tv_usec) / 1000); } else { // do user defined cron handle_->CronHandle(); diff --git a/src/net/src/bg_thread.cc b/src/net/src/bg_thread.cc index c7266ac7c4..49a0c519e9 100644 --- a/src/net/src/bg_thread.cc +++ b/src/net/src/bg_thread.cc @@ -26,8 +26,8 @@ void BGThread::Schedule(void (*function)(void*), void* arg) { void BGThread::QueueSize(int* pri_size, int* qu_size) { std::lock_guard lock(mu_); - *pri_size = timer_queue_.size(); - *qu_size = queue_.size(); + *pri_size = static_cast(timer_queue_.size()); + *qu_size = static_cast(queue_.size()); } void BGThread::QueueClear() { diff --git a/src/net/src/client_thread.cc b/src/net/src/client_thread.cc index e5dd77a821..ef6a6e727d 100644 --- a/src/net/src/client_thread.cc +++ b/src/net/src/client_thread.cc @@ -305,7 +305,7 @@ void ClientThread::NotifyWrite(const std::string& ip_port) { void ClientThread::ProcessNotifyEvents(const NetFiredEvent* pfe) { if (pfe->mask & kReadable) { char bb[2048]; - int32_t nread = read(net_multiplexer_->NotifyReceiveFd(), bb, 2048); + int64_t nread = read(net_multiplexer_->NotifyReceiveFd(), bb, 2048); if (nread == 0) { return; } else { @@ -381,7 +381,7 @@ void* ClientThread::ThreadMain() { if (cron_interval_ > 0) { gettimeofday(&now, nullptr); if (when.tv_sec > now.tv_sec || (when.tv_sec == now.tv_sec && when.tv_usec > now.tv_usec)) { - timeout = (when.tv_sec - now.tv_sec) * 1000 + (when.tv_usec - now.tv_usec) / 1000; + timeout = static_cast((when.tv_sec - now.tv_sec) * 1000 + (when.tv_usec - now.tv_usec) / 1000); } else { // do user defined cron handle_->CronHandle(); diff --git a/src/net/src/holy_thread.cc b/src/net/src/holy_thread.cc index b7c2f1990a..cb12906880 100644 --- a/src/net/src/holy_thread.cc +++ b/src/net/src/holy_thread.cc @@ -35,7 +35,7 @@ HolyThread::~HolyThread() { Cleanup(); } int HolyThread::conn_num() const { std::shared_lock l(rwlock_); - return conns_.size(); + return static_cast(conns_.size()); } std::vector HolyThread::conns_info() const { @@ -279,7 +279,7 @@ bool HolyThread::KillConn(const std::string& ip_port) { void HolyThread::ProcessNotifyEvents(const net::NetFiredEvent* pfe) { if (pfe->mask & kReadable) { char bb[2048]; - int32_t nread = read(net_multiplexer_->NotifyReceiveFd(), bb, 2048); + int64_t nread = read(net_multiplexer_->NotifyReceiveFd(), bb, 2048); if (nread == 0) { return; } else { diff --git a/src/net/src/http_conn.cc b/src/net/src/http_conn.cc index 6ec7915b9f..027afd5e36 100644 --- a/src/net/src/http_conn.cc +++ b/src/net/src/http_conn.cc @@ -173,7 +173,7 @@ int HTTPRequest::ParseHeader() { // Haven't find header return 0; } - int header_len = sep_pos - rbuf_ + 4; + auto header_len = static_cast(sep_pos - rbuf_ + 4); int remain_size = header_len; if (remain_size <= 5) { // Header error diff --git a/src/net/src/net_cli.cc b/src/net/src/net_cli.cc index 41c1e7aaf0..76196826b7 100644 --- a/src/net/src/net_cli.cc +++ b/src/net/src/net_cli.cc @@ -153,7 +153,7 @@ Status NetCli::Connect(const std::string& ip, const int port, const std::string& static int PollFd(int fd, int events, int ms) { pollfd fds[1]; fds[0].fd = fd; - fds[0].events = events; + fds[0].events = static_cast(events); fds[0].revents = 0; int ret = ::poll(fds, 1, ms); @@ -170,7 +170,7 @@ static int CheckSockAliveness(int fd) { ret = PollFd(fd, POLLIN | POLLPRI, 0); if (0 < ret) { - int num = ::recv(fd, buf, 1, MSG_PEEK); + int64_t num = ::recv(fd, buf, 1, MSG_PEEK); if (num == 0) { return -1; } @@ -212,7 +212,7 @@ int NetCli::CheckAliveness() { Status NetCli::SendRaw(void* buf, size_t count) { char* wbuf = reinterpret_cast(buf); size_t nleft = count; - int pos = 0; + ssize_t pos = 0; ssize_t nwritten; while (nleft > 0) { diff --git a/src/net/src/net_pubsub.cc b/src/net/src/net_pubsub.cc index b7513454c3..e2a1ec1cb4 100644 --- a/src/net/src/net_pubsub.cc +++ b/src/net/src/net_pubsub.cc @@ -298,7 +298,8 @@ void PubSubThread::PubSubChannels(const std::string& pattern, std::vector(channel.first.size()), + pattern.c_str(), static_cast(pattern.size()), 0)) { if (!channel.second.empty()) { result->push_back(channel.first); } @@ -315,7 +316,7 @@ void PubSubThread::PubSubNumSub(const std::vector& channels, subscribed = 0; for (auto& channel : pubsub_channel_) { if (channel.first == i) { - subscribed = channel.second.size(); + subscribed = static_cast(channel.second.size()); } } result->push_back(std::make_pair(i, subscribed)); @@ -326,7 +327,7 @@ int PubSubThread::PubSubNumPat() { int subscribed = 0; std::lock_guard l(pattern_mutex_); for (auto& channel : pubsub_pattern_) { - subscribed += channel.second.size(); + subscribed += static_cast(channel.second.size()); } return subscribed; } @@ -402,8 +403,9 @@ void* PubSubThread::ThreadMain() { // Send message to a channel pattern's clients pattern_mutex_.lock(); - for (auto & it : pubsub_pattern_) { - if (pstd::stringmatchlen(it.first.c_str(), it.first.size(), channel.c_str(), channel.size(), 0)) { + for (auto& it : pubsub_pattern_) { + if (pstd::stringmatchlen(it.first.c_str(), static_cast(it.first.size()), + channel.c_str(), static_cast(channel.size()), 0)) { for (size_t i = 0; i < it.second.size(); i++) { if (!IsReady(it.second[i]->fd())) { continue; diff --git a/src/net/src/pb_cli.cc b/src/net/src/pb_cli.cc index f6e4ea0e07..fbea5d1267 100644 --- a/src/net/src/pb_cli.cc +++ b/src/net/src/pb_cli.cc @@ -51,10 +51,10 @@ PbCli::~PbCli() { Status PbCli::Send(void* msg) { auto req = reinterpret_cast(msg); - int wbuf_len = req->ByteSizeLong(); - req->SerializeToArray(wbuf_ + kCommandHeaderLength, wbuf_len); - uint32_t len = htonl(wbuf_len); - memcpy(wbuf_, &len, sizeof(uint32_t)); + size_t wbuf_len = req->ByteSizeLong(); + req->SerializeToArray(wbuf_ + kCommandHeaderLength, static_cast(wbuf_len)); + uint32_t len = htonl(static_cast(wbuf_len)); + memcpy(wbuf_, &len, sizeof(len)); wbuf_len += kCommandHeaderLength; return NetCli::SendRaw(wbuf_, wbuf_len); @@ -80,7 +80,7 @@ Status PbCli::Recv(void* msg_res) { return s; } - if (!res->ParseFromArray(rbuf_, packet_len)) { + if (!res->ParseFromArray(rbuf_, static_cast(packet_len))) { return Status::Corruption("PbCli::Recv Protobuf ParseFromArray error"); } return Status::OK(); diff --git a/src/net/src/pb_conn.cc b/src/net/src/pb_conn.cc index c087f1eb78..aec1010a9d 100644 --- a/src/net/src/pb_conn.cc +++ b/src/net/src/pb_conn.cc @@ -48,7 +48,7 @@ ReadStatus PbConn::GetRequest() { uint32_t integer = 0; memcpy(reinterpret_cast(&integer), rbuf_, sizeof(uint32_t)); header_len_ = ntohl(integer); - remain_packet_len_ = header_len_; + remain_packet_len_ = static_cast(header_len_); connStatus_ = kPacket; continue; } @@ -80,8 +80,8 @@ ReadStatus PbConn::GetRequest() { } else if (nread == 0) { return kReadClose; } - cur_pos_ += nread; - remain_packet_len_ -= nread; + cur_pos_ += static_cast(nread); + remain_packet_len_ -= static_cast(nread); if (remain_packet_len_ == 0) { connStatus_ = kComplete; continue; @@ -178,7 +178,7 @@ void PbConn::BuildInternalTag(const std::string& resp, std::string* tag) { void PbConn::TryResizeBuffer() { struct timeval now; gettimeofday(&now, nullptr); - int idletime = now.tv_sec - last_interaction().tv_sec; + time_t idletime = now.tv_sec - last_interaction().tv_sec; if (rbuf_len_ > PB_IOBUF_LEN && ((rbuf_len_ / (cur_pos_ + 1)) > 2 || idletime > 2)) { uint32_t new_size = ((cur_pos_ + PB_IOBUF_LEN) / PB_IOBUF_LEN) * PB_IOBUF_LEN; if (new_size < rbuf_len_) { diff --git a/src/net/src/redis_cli.cc b/src/net/src/redis_cli.cc index 663f57ba86..fe8fb51b75 100644 --- a/src/net/src/redis_cli.cc +++ b/src/net/src/redis_cli.cc @@ -88,7 +88,7 @@ Status RedisCli::Send(void* msg) { const char* wbuf = storage->data(); size_t nleft = storage->size(); - int wbuf_pos = 0; + ssize_t wbuf_pos = 0; ssize_t nwritten; while (nleft > 0) { @@ -164,7 +164,7 @@ ssize_t RedisCli::BufferRead() { return REDIS_EREAD_NULL; } - rbuf_offset_ += nread; + rbuf_offset_ += static_cast(nread); return nread; } } @@ -172,7 +172,7 @@ ssize_t RedisCli::BufferRead() { /* Find pointer to \r\n. */ static char* seekNewline(char* s, size_t len) { int pos = 0; - int _len = len - 1; + auto _len = static_cast(len - 1); /* Position should be < len-1 because the character at "pos" should be * followed by a \n. Note that strchr cannot be used because it doesn't @@ -252,8 +252,8 @@ int RedisCli::ProcessBulkItem() { p = rbuf_ + rbuf_pos_; s = seekNewline(p, rbuf_offset_); if (s) { - bytelen = s - p + 2; /* include \r\n */ - len = readLongLong(p); + bytelen = static_cast(s - p + 2); /* include \r\n */ + len = static_cast(readLongLong(p)); if (len == -1) { elements_--; @@ -280,7 +280,7 @@ int RedisCli::ProcessMultiBulkItem() { int len; if (p = ReadLine(&len); p) { - elements_ = readLongLong(p); + elements_ = static_cast(readLongLong(p)); return REDIS_OK; } @@ -294,7 +294,7 @@ int RedisCli::GetReply() { while (elements_ > 0) { // Should read again if (rbuf_offset_ == 0 || result == REDIS_HALF) { - if ((result = BufferRead()) < 0) { + if ((result = static_cast(BufferRead())) < 0) { return result; } } @@ -312,8 +312,8 @@ char* RedisCli::ReadBytes(unsigned int bytes) { char* p = nullptr; if (static_cast(rbuf_offset_) >= bytes) { p = rbuf_ + rbuf_pos_; - rbuf_pos_ += bytes; - rbuf_offset_ -= bytes; + rbuf_pos_ += static_cast(bytes); + rbuf_offset_ -= static_cast(bytes); } return p; } @@ -326,7 +326,7 @@ char* RedisCli::ReadLine(int* _len) { p = rbuf_ + rbuf_pos_; s = seekNewline(p, rbuf_offset_); if (s) { - len = s - (rbuf_ + rbuf_pos_); + len = static_cast(s - (rbuf_ + rbuf_pos_)); rbuf_pos_ += len + 2; /* skip \r\n */ rbuf_offset_ -= len + 2; if (_len) { @@ -411,7 +411,7 @@ static int intlen(int i) { } // Helper that calculates the bulk length given a certain string length. -static size_t bulklen(size_t len) { return 1 + intlen(len) + 2 + len + 2; } +static size_t bulklen(size_t len) { return 1 + intlen(static_cast(len)) + 2 + len + 2; } int redisvFormatCommand(std::string* cmd, const char* format, va_list ap) { const char* c = format; @@ -573,7 +573,7 @@ int redisvFormatCommand(std::string* cmd, const char* format, va_list ap) { } /* Add bytes needed to hold multi bulk count */ - totlen += 1 + intlen(args.size()) + 2; + totlen += 1 + intlen(static_cast(args.size())) + 2; /* Build the command at protocol level */ cmd->clear(); @@ -591,7 +591,7 @@ int redisvFormatCommand(std::string* cmd, const char* format, va_list ap) { } assert(cmd->size() == totlen); - return totlen; + return static_cast(totlen); } int redisvAppendCommand(std::string* cmd, const char* format, va_list ap) { @@ -606,7 +606,7 @@ int redisvAppendCommand(std::string* cmd, const char* format, va_list ap) { int redisFormatCommandArgv(RedisCmdArgsType argv, std::string* cmd) { size_t argc = argv.size(); - int totlen = 1 + intlen(argc) + 2; + size_t totlen = 1 + intlen(static_cast(argc)) + 2; for (size_t i = 0; i < argc; i++) { totlen += bulklen(argv[i].size()); } diff --git a/src/net/src/redis_conn.cc b/src/net/src/redis_conn.cc index 9cd5b3be2c..2c09190de2 100644 --- a/src/net/src/redis_conn.cc +++ b/src/net/src/redis_conn.cc @@ -66,8 +66,8 @@ ReadStatus RedisConn::GetRequest() { ssize_t nread = 0; int next_read_pos = last_read_pos_ + 1; - int remain = rbuf_len_ - next_read_pos; // Remain buffer size - int new_size = 0; + int64_t remain = rbuf_len_ - next_read_pos; // Remain buffer size + int64_t new_size = 0; if (remain == 0) { new_size = rbuf_len_ + REDIS_IOBUF_LEN; remain += REDIS_IOBUF_LEN; @@ -83,7 +83,7 @@ ReadStatus RedisConn::GetRequest() { if (!rbuf_) { return kFullError; } - rbuf_len_ = new_size; + rbuf_len_ = static_cast(new_size); } nread = read(fd(), rbuf_ + next_read_pos, remain); @@ -100,16 +100,16 @@ ReadStatus RedisConn::GetRequest() { return kReadClose; } // assert(nread > 0); - last_read_pos_ += nread; + last_read_pos_ += static_cast(nread); msg_peak_ = last_read_pos_; - command_len_ += nread; + command_len_ += static_cast (nread); if (command_len_ >= rbuf_max_len_) { LOG(INFO) << "close conn command_len " << command_len_ << ", rbuf_max_len " << rbuf_max_len_; return kFullError; } int processed_len = 0; - RedisParserStatus ret = redis_parser_.ProcessInputBuffer(rbuf_ + next_read_pos, nread, &processed_len); + RedisParserStatus ret = redis_parser_.ProcessInputBuffer(rbuf_ + next_read_pos, static_cast(nread), &processed_len); ReadStatus read_status = ParseRedisParserStatus(ret); if (read_status == kReadAll || read_status == kReadHalf) { if (read_status == kReadAll) { @@ -170,7 +170,7 @@ int RedisConn::WriteResp(const std::string& resp) { void RedisConn::TryResizeBuffer() { struct timeval now; gettimeofday(&now, nullptr); - int idletime = now.tv_sec - last_interaction().tv_sec; + time_t idletime = now.tv_sec - last_interaction().tv_sec; if (rbuf_len_ > REDIS_MBULK_BIG_ARG && ((rbuf_len_ / (msg_peak_ + 1)) > 2 || idletime > 2)) { int new_size = ((last_read_pos_ + REDIS_IOBUF_LEN) / REDIS_IOBUF_LEN) * REDIS_IOBUF_LEN; if (new_size < rbuf_len_) { diff --git a/src/net/src/redis_parser.cc b/src/net/src/redis_parser.cc index 12d8a2c4c1..93a017118b 100644 --- a/src/net/src/redis_parser.cc +++ b/src/net/src/redis_parser.cc @@ -49,7 +49,7 @@ static int split2args(const std::string& req_buf, RedisCmdArgsType& argv) { while (done == 0) { if (inq != 0) { if (*p == '\\' && *(p + 1) == 'x' && IsHexDigit(*(p + 2)) && IsHexDigit(*(p + 3))) { - unsigned char byte = HexDigitToInt32(*(p + 2)) * 16 + HexDigitToInt32(*(p + 3)); + char byte = static_cast(HexDigitToInt32(*(p + 2)) * 16 + HexDigitToInt32(*(p + 3))); arg.append(1, byte); p += 3; } else if (*p == '\\' && (*(p + 1) != 0)) { @@ -279,7 +279,7 @@ RedisParserStatus RedisParser::ProcessMultibulkBuffer() { break; } else { argv_.emplace_back(input_buf_ + cur_pos_, bulk_len_); - cur_pos_ = cur_pos_ + bulk_len_ + 2; + cur_pos_ = static_cast(cur_pos_ + bulk_len_ + 2); bulk_len_ = -1; multibulk_len_--; } @@ -316,7 +316,7 @@ RedisParserStatus RedisParser::ProcessInputBuffer(const char* input_buf, int len std::string tmp_str(input_buf, length); input_str_ = half_argv_ + tmp_str; input_buf_ = input_str_.c_str(); - length_ = length + half_argv_.size(); + length_ = static_cast(length + half_argv_.size()); if (redis_parser_type_ == REDIS_PARSER_REQUEST) { ProcessRequestBuffer(); } else if (redis_parser_type_ == REDIS_PARSER_RESPONSE) { diff --git a/src/net/src/server_thread.cc b/src/net/src/server_thread.cc index a4f0e72f54..078f0ac751 100644 --- a/src/net/src/server_thread.cc +++ b/src/net/src/server_thread.cc @@ -180,7 +180,7 @@ void* ServerThread::ThreadMain() { if (cron_interval_ > 0) { gettimeofday(&now, nullptr); if (when.tv_sec > now.tv_sec || (when.tv_sec == now.tv_sec && when.tv_usec > now.tv_usec)) { - timeout = (when.tv_sec - now.tv_sec) * 1000 + (when.tv_usec - now.tv_usec) / 1000; + timeout = static_cast((when.tv_sec - now.tv_sec) * 1000 + (when.tv_usec - now.tv_usec) / 1000); } else { // Do own cron task as well as user's DoCronTask(); diff --git a/src/net/src/simple_http_conn.cc b/src/net/src/simple_http_conn.cc index 425d66835b..8310f7e3d2 100644 --- a/src/net/src/simple_http_conn.cc +++ b/src/net/src/simple_http_conn.cc @@ -239,7 +239,7 @@ int Response::SerializeHeaderToArray(char* data, size_t size) { // Serialize header if (headers_.find("Content-Length") == headers_.end()) { - SetHeaders("Content-Length", body_.size()); + SetHeaders("Content-Length", static_cast(body_.size())); } for (auto& line : headers_) { ret = snprintf(data + serial_size, size - serial_size, "%s: %s\r\n", line.first.c_str(), line.second.c_str()); @@ -260,13 +260,13 @@ int Response::SerializeHeaderToArray(char* data, size_t size) { // Serialize body begin from 'pos', return the new pos int Response::SerializeBodyToArray(char* data, size_t size, int* pos) { // Serialize body - int actual = size; + size_t actual = size; if (body_.size() - *pos < size) { actual = body_.size() - *pos; } memcpy(data, body_.data() + *pos, actual); - *pos += actual; - return actual; + *pos += static_cast(actual); + return static_cast(actual); } void Response::SetStatusCode(int code) { @@ -297,7 +297,7 @@ SimpleHTTPConn::~SimpleHTTPConn() { */ bool SimpleHTTPConn::BuildRequestHeader() { request_->Clear(); - if (!request_->ParseHeadFromArray(rbuf_, header_len_)) { + if (!request_->ParseHeadFromArray(rbuf_, static_cast(header_len_))) { return false; } auto iter = request_->headers.find("content-length"); @@ -319,7 +319,7 @@ bool SimpleHTTPConn::BuildRequestHeader() { } bool SimpleHTTPConn::AppendRequestBody() { - return request_->ParseBodyFromArray(rbuf_ + header_len_, rbuf_pos_ - header_len_); + return request_->ParseBodyFromArray(rbuf_ + header_len_, static_cast(rbuf_pos_ - header_len_)); } void SimpleHTTPConn::HandleMessage() { diff --git a/src/net/src/worker_thread.cc b/src/net/src/worker_thread.cc index dff3295aff..81e69a4013 100644 --- a/src/net/src/worker_thread.cc +++ b/src/net/src/worker_thread.cc @@ -32,7 +32,7 @@ WorkerThread::~WorkerThread() = default; int WorkerThread::conn_num() const { std::shared_lock lock(rwlock_); - return conns_.size(); + return static_cast(conns_.size()); } std::vector WorkerThread::conns_info() const { @@ -92,7 +92,7 @@ void* WorkerThread::ThreadMain() { if (cron_interval_ > 0) { gettimeofday(&now, nullptr); if (when.tv_sec > now.tv_sec || (when.tv_sec == now.tv_sec && when.tv_usec > now.tv_usec)) { - timeout = (when.tv_sec - now.tv_sec) * 1000 + (when.tv_usec - now.tv_usec) / 1000; + timeout = static_cast((when.tv_sec - now.tv_sec) * 1000 + (when.tv_usec - now.tv_usec) / 1000); } else { DoCronTask(); when.tv_sec = now.tv_sec + (cron_interval_ / 1000); @@ -110,7 +110,7 @@ void* WorkerThread::ThreadMain() { } if (pfe->fd == net_multiplexer_->NotifyReceiveFd()) { if ((pfe->mask & kReadable) != 0) { - int32_t nread = read(net_multiplexer_->NotifyReceiveFd(), bb, 2048); + auto nread = static_cast(read(net_multiplexer_->NotifyReceiveFd(), bb, 2048)); if (nread == 0) { continue; } else { diff --git a/src/pika.cc b/src/pika.cc index 17bc22d674..a30d8b0ec1 100644 --- a/src/pika.cc +++ b/src/pika.cc @@ -135,7 +135,7 @@ int main(int argc, char* argv[]) { bool path_opt = false; signed char c; char path[1024]; - while (-1 != (c = getopt(argc, argv, "c:hv"))) { + while (-1 != (c = static_cast(getopt(argc, argv, "c:hv")))) { switch (c) { case 'c': snprintf(path, 1024, "%s", optarg); diff --git a/src/pika_admin.cc b/src/pika_admin.cc index 3765eaec0e..c43470091c 100644 --- a/src/pika_admin.cc +++ b/src/pika_admin.cc @@ -142,7 +142,7 @@ void SlaveofCmd::Do(std::shared_ptr slot) { return; } - bool sm_ret = g_pika_server->SetMaster(master_ip_, master_port_); + bool sm_ret = g_pika_server->SetMaster(master_ip_, static_cast(master_port_)); if (sm_ret) { res_.SetRes(CmdRes::kOk); @@ -460,7 +460,7 @@ std::string FlushallCmd::ToBinlog(uint32_t exec_time, uint32_t term_id, uint64_t // to flushdb cmd std::string flushdb_cmd("flushdb"); - RedisAppendLen(content, flushdb_cmd.size(), "$"); + RedisAppendLenUint64(content, flushdb_cmd.size(), "$"); RedisAppendContent(content, flushdb_cmd); return PikaBinlogTransverter::BinlogEncode(BinlogType::TypeFirst, exec_time, term_id, logic_id, filenum, offset, content, {}); @@ -788,8 +788,7 @@ void InfoCmd::Do(std::shared_ptr slot) { break; } - res_.AppendStringLen(info.size()); - res_.AppendContent(info); + res_.AppendString(info); } void InfoCmd::InfoServer(std::string& info) { @@ -1146,12 +1145,12 @@ void InfoCmd::InfoData(std::string& info) { std::stringstream tmp_stream; std::stringstream db_fatal_msg_stream; - int64_t db_size = pstd::Du(g_pika_conf->db_path()); + uint64_t db_size = pstd::Du(g_pika_conf->db_path()); tmp_stream << "# Data" << "\r\n"; tmp_stream << "db_size:" << db_size << "\r\n"; tmp_stream << "db_size_human:" << (db_size >> 20) << "M\r\n"; - int64_t log_size = pstd::Du(g_pika_conf->log_path()); + uint64_t log_size = pstd::Du(g_pika_conf->log_path()); tmp_stream << "log_size:" << log_size << "\r\n"; tmp_stream << "log_size_human:" << (log_size >> 20) << "M\r\n"; tmp_stream << "compression:" << g_pika_conf->compression() << "\r\n"; @@ -1249,7 +1248,9 @@ void InfoCmd::InfoCommandStats(std::string& info) { tmp_stream << "cmdstat_" << iter.first << ":" << "calls=" << iter.second.cmd_count << ",usec=" << iter.second.cmd_time_consuming - << ",usec_per_call=" << (iter.second.cmd_time_consuming * 1.0) / iter.second.cmd_count << "\r\n"; + << ",usec_per_call=" + << static_cast(iter.second.cmd_time_consuming) / static_cast(iter.second.cmd_count) + << "\r\n"; } } info.append(tmp_stream.str()); @@ -1777,7 +1778,7 @@ void ConfigCmd::ConfigSet(std::string& ret) { ret = "-ERR Invalid argument " + value + " for CONFIG SET 'timeout'\r\n"; return; } - g_pika_conf->SetTimeout(ival); + g_pika_conf->SetTimeout(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "requirepass") { g_pika_conf->SetRequirePass(value); @@ -1802,43 +1803,43 @@ void ConfigCmd::ConfigSet(std::string& ret) { ret = "-ERR Invalid argument \'" + value + "\' for CONFIG SET 'maxclients'\r\n"; return; } - g_pika_conf->SetMaxConnection(ival); - g_pika_server->SetDispatchQueueLimit(ival); + g_pika_conf->SetMaxConnection(static_cast(ival)); + g_pika_server->SetDispatchQueueLimit(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "dump-expire") { if (pstd::string2int(value.data(), value.size(), &ival) == 0) { ret = "-ERR Invalid argument \'" + value + "\' for CONFIG SET 'dump-expire'\r\n"; return; } - g_pika_conf->SetExpireDumpDays(ival); + g_pika_conf->SetExpireDumpDays(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "slave-priority") { if (pstd::string2int(value.data(), value.size(), &ival) == 0) { ret = "-ERR Invalid argument \'" + value + "\' for CONFIG SET 'slave-priority'\r\n"; return; } - g_pika_conf->SetSlavePriority(ival); + g_pika_conf->SetSlavePriority(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "expire-logs-days") { if ((pstd::string2int(value.data(), value.size(), &ival) == 0) || ival <= 0) { ret = "-ERR Invalid argument \'" + value + "\' for CONFIG SET 'expire-logs-days'\r\n"; return; } - g_pika_conf->SetExpireLogsDays(ival); + g_pika_conf->SetExpireLogsDays(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "expire-logs-nums") { if ((pstd::string2int(value.data(), value.size(), &ival) == 0) || ival <= 0) { ret = "-ERR Invalid argument \'" + value + "\' for CONFIG SET 'expire-logs-nums'\r\n"; return; } - g_pika_conf->SetExpireLogsNums(ival); + g_pika_conf->SetExpireLogsNums(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "root-connection-num") { if ((pstd::string2int(value.data(), value.size(), &ival) == 0) || ival <= 0) { ret = "-ERR Invalid argument \'" + value + "\' for CONFIG SET 'root-connection-num'\r\n"; return; } - g_pika_conf->SetRootConnectionNum(ival); + g_pika_conf->SetRootConnectionNum(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "slowlog-write-errorlog") { bool is_write_errorlog; @@ -1857,14 +1858,14 @@ void ConfigCmd::ConfigSet(std::string& ret) { ret = "-ERR Invalid argument \'" + value + "\' for CONFIG SET 'slowlog-log-slower-than'\r\n"; return; } - g_pika_conf->SetSlowlogSlowerThan(ival); + g_pika_conf->SetSlowlogSlowerThan(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "slowlog-max-len") { if ((pstd::string2int(value.data(), value.size(), &ival) == 0) || ival < 0) { ret = "-ERR Invalid argument \'" + value + "\' for CONFIG SET 'slowlog-max-len'\r\n"; return; } - g_pika_conf->SetSlowlogMaxLen(ival); + g_pika_conf->SetSlowlogMaxLen(static_cast(ival)); g_pika_server->SlowlogTrim(); ret = "+OK\r\n"; } else if (set_item == "max-cache-statistic-keys") { @@ -1872,23 +1873,23 @@ void ConfigCmd::ConfigSet(std::string& ret) { ret = "-ERR Invalid argument \'" + value + "\' for CONFIG SET 'max-cache-statistic-keys'\r\n"; return; } - g_pika_conf->SetMaxCacheStatisticKeys(ival); - g_pika_server->SlotSetMaxCacheStatisticKeys(ival); + g_pika_conf->SetMaxCacheStatisticKeys(static_cast(ival)); + g_pika_server->SlotSetMaxCacheStatisticKeys(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "small-compaction-threshold") { if ((pstd::string2int(value.data(), value.size(), &ival) == 0) || ival < 0) { ret = "-ERR Invalid argument \'" + value + "\' for CONFIG SET 'small-compaction-threshold'\r\n"; return; } - g_pika_conf->SetSmallCompactionThreshold(ival); - g_pika_server->SlotSetSmallCompactionThreshold(ival); + g_pika_conf->SetSmallCompactionThreshold(static_cast(ival)); + g_pika_server->SlotSetSmallCompactionThreshold(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "max-client-response-size") { if ((pstd::string2int(value.data(), value.size(), &ival) == 0) || ival < 0) { ret = "-ERR Invalid argument \'" + value + "\' for CONFIG SET 'max-client-response-size'\r\n"; return; } - g_pika_conf->SetMaxClientResponseSize(ival); + g_pika_conf->SetMaxClientResponseSize(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "write-binlog") { int role = g_pika_server->role(); @@ -1910,7 +1911,7 @@ void ConfigCmd::ConfigSet(std::string& ret) { if (ival < 0 || ival > 1024) { ival = 1024; } - g_pika_conf->SetDbSyncSpeed(ival); + g_pika_conf->SetDbSyncSpeed(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "compact-cron") { bool invalid = false; @@ -1918,7 +1919,7 @@ void ConfigCmd::ConfigSet(std::string& ret) { bool have_week = false; std::string compact_cron; std::string week_str; - int slash_num = count(value.begin(), value.end(), '/'); + int64_t slash_num = count(value.begin(), value.end(), '/'); if (slash_num == 2) { have_week = true; std::string::size_type first_slash = value.find('/'); @@ -1983,7 +1984,7 @@ void ConfigCmd::ConfigSet(std::string& ret) { ret = "-ERR Argument exceed range \'" + value + "\' for CONFIG SET 'sync-window-size'\r\n"; return; } - g_pika_conf->SetSyncWindowSize(ival); + g_pika_conf->SetSyncWindowSize(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "max-cache-files") { if (pstd::string2int(value.data(), value.size(), &ival) == 0) { @@ -1996,7 +1997,7 @@ void ConfigCmd::ConfigSet(std::string& ret) { ret = "-ERR Set max-cache-files wrong: " + s.ToString() + "\r\n"; return; } - g_pika_conf->SetMaxCacheFiles(ival); + g_pika_conf->SetMaxCacheFiles(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "max-background-compactions") { if (pstd::string2int(value.data(), value.size(), &ival) == 0) { @@ -2009,7 +2010,7 @@ void ConfigCmd::ConfigSet(std::string& ret) { ret = "-ERR Set max-background-compactions wrong: " + s.ToString() + "\r\n"; return; } - g_pika_conf->SetMaxBackgroudCompactions(ival); + g_pika_conf->SetMaxBackgroudCompactions(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "write-buffer-size") { if (pstd::string2int(value.data(), value.size(), &ival) == 0) { @@ -2022,7 +2023,7 @@ void ConfigCmd::ConfigSet(std::string& ret) { ret = "-ERR Set write-buffer-size wrong: " + s.ToString() + "\r\n"; return; } - g_pika_conf->SetWriteBufferSize(ival); + g_pika_conf->SetWriteBufferSize(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "max-write-buffer-num") { if (pstd::string2int(value.data(), value.size(), &ival) == 0) { @@ -2035,7 +2036,7 @@ void ConfigCmd::ConfigSet(std::string& ret) { ret = "-ERR Set max-write-buffer-number wrong: " + s.ToString() + "\r\n"; return; } - g_pika_conf->SetMaxWriteBufferNumber(ival); + g_pika_conf->SetMaxWriteBufferNumber(static_cast(ival)); ret = "+OK\r\n"; } else if (set_item == "arena-block-size") { if (pstd::string2int(value.data(), value.size(), &ival) == 0) { @@ -2048,7 +2049,7 @@ void ConfigCmd::ConfigSet(std::string& ret) { ret = "-ERR Set arena-block-size wrong: " + s.ToString() + "\r\n"; return; } - g_pika_conf->SetArenaBlockSize(ival); + g_pika_conf->SetArenaBlockSize(static_cast(ival)); ret = "+OK\r\n"; } else { ret = "-ERR Unsupported CONFIG parameter: " + set_item + "\r\n"; @@ -2105,8 +2106,8 @@ void DbsizeCmd::Do(std::shared_ptr slot) { res_.SetRes(CmdRes::kErrOther, "keyspace error"); return; } - int64_t dbsize = key_infos[0].keys + key_infos[1].keys + key_infos[2].keys + key_infos[3].keys + key_infos[4].keys; - res_.AppendInteger(dbsize); + uint64_t dbsize = key_infos[0].keys + key_infos[1].keys + key_infos[2].keys + key_infos[3].keys + key_infos[4].keys; + res_.AppendInteger(static_cast(dbsize)); } } @@ -2157,7 +2158,7 @@ void DelbackupCmd::Do(std::shared_ptr slot) { return; } - int len = dump_dir.size(); + int len = static_cast(dump_dir.size()); for (auto& i : dump_dir) { if (i.substr(0, db_sync_prefix.size()) != db_sync_prefix || i.size() != (db_sync_prefix.size() + 8)) { continue; @@ -2256,13 +2257,13 @@ void SlowlogCmd::Do(std::shared_ptr slot) { } else { std::vector slowlogs; g_pika_server->SlowlogObtain(number_, &slowlogs); - res_.AppendArrayLen(slowlogs.size()); + res_.AppendArrayLenUint64(slowlogs.size()); for (const auto& slowlog : slowlogs) { res_.AppendArrayLen(4); res_.AppendInteger(slowlog.id); res_.AppendInteger(slowlog.start_time); res_.AppendInteger(slowlog.duration); - res_.AppendArrayLen(slowlog.argv.size()); + res_.AppendArrayLenUint64(slowlog.argv.size()); for (const auto& arg : slowlog.argv) { res_.AppendString(arg); } @@ -2422,17 +2423,17 @@ void HelloCmd::Do(std::shared_ptr slot) { } for (const auto& fv : fvs) { - RedisAppendLen(raw, fv.field.size(), "$"); + RedisAppendLenUint64(raw, fv.field.size(), "$"); RedisAppendContent(raw, fv.field); if (fv.field == "proto") { pstd::string2int(fv.value.data(), fv.value.size(), &ver); RedisAppendLen(raw, static_cast(ver), ":"); continue; } - RedisAppendLen(raw, fv.value.size(), "$"); + RedisAppendLenUint64(raw, fv.value.size(), "$"); RedisAppendContent(raw, fv.value); } - res_.AppendArrayLen(fvs.size() * 2); + res_.AppendArrayLenUint64(fvs.size() * 2); res_.AppendStringRaw(raw); } diff --git a/src/pika_binlog.cc b/src/pika_binlog.cc index 40ade37dd6..534710f108 100644 --- a/src/pika_binlog.cc +++ b/src/pika_binlog.cc @@ -139,7 +139,7 @@ void Binlog::InitLogFile() { assert(queue_ != nullptr); uint64_t filesize = queue_->Filesize(); - block_offset_ = filesize % kBlockSize; + block_offset_ = static_cast(filesize % kBlockSize); opened_.store(true); } @@ -168,7 +168,7 @@ Status Binlog::Put(const std::string& item) { if (!opened_.load()) { return Status::Busy("Binlog is not open yet"); } - Status s = Put(item.c_str(), item.size()); + Status s = Put(item.c_str(), static_cast(item.size())); if (!s.ok()) { binlog_io_error_.store(true); } @@ -241,9 +241,9 @@ Status Binlog::EmitPhysicalRecord(RecordType t, const char* ptr, size_t n, int* s = queue_->Flush(); } } - block_offset_ += static_cast(kHeaderSize + n); + block_offset_ += static_cast(kHeaderSize + n); - *temp_pro_offset += kHeaderSize + n; + *temp_pro_offset += static_cast(kHeaderSize + n); return s; } @@ -253,7 +253,7 @@ Status Binlog::Produce(const pstd::Slice& item, int* temp_pro_offset) { size_t left = item.size(); bool begin = true; - *temp_pro_offset = version_->pro_offset_; + *temp_pro_offset = static_cast(version_->pro_offset_); do { const int leftover = static_cast(kBlockSize) - block_offset_; assert(leftover >= 0); @@ -386,7 +386,7 @@ Status Binlog::Truncate(uint32_t pro_num, uint64_t pro_offset, uint64_t index) { if (fd < 0) { return Status::IOError("fd open failed"); } - if (ftruncate(fd, pro_offset) != 0) { + if (ftruncate(fd, static_cast(pro_offset)) != 0) { return Status::IOError("ftruncate failed"); } close(fd); diff --git a/src/pika_binlog_transverter.cc b/src/pika_binlog_transverter.cc index 2bf158ccfd..41207cfe93 100644 --- a/src/pika_binlog_transverter.cc +++ b/src/pika_binlog_transverter.cc @@ -126,7 +126,7 @@ std::string PikaBinlogTransverter::ConstructPaddingBinlog(BinlogType type, uint3 pstd::PutFixed64(&binlog, 0); pstd::PutFixed32(&binlog, 0); pstd::PutFixed64(&binlog, 0); - int32_t content_len = size - BINLOG_ITEM_HEADER_SIZE; + auto content_len = static_cast(size - BINLOG_ITEM_HEADER_SIZE); int32_t parameter_len = content_len - PADDING_BINLOG_PROTOCOL_SIZE - SPACE_STROE_PARAMETER_LENGTH; if (parameter_len < 0) { return {}; diff --git a/src/pika_bit.cc b/src/pika_bit.cc index f35cfad2ac..8b187164d8 100644 --- a/src/pika_bit.cc +++ b/src/pika_bit.cc @@ -42,7 +42,7 @@ void BitSetCmd::DoInitial() { void BitSetCmd::Do(std::shared_ptr slot) { std::string value; int32_t bit_val = 0; - rocksdb::Status s = slot->db()->SetBit(key_, bit_offset_, on_, &bit_val); + rocksdb::Status s = slot->db()->SetBit(key_, bit_offset_, static_cast(on_), &bit_val); if (s.ok()) { res_.AppendInteger(static_cast(bit_val)); AddSlotKey("k", key_, slot); @@ -160,11 +160,11 @@ void BitPosCmd::Do(std::shared_ptr slot) { int64_t pos = 0; rocksdb::Status s; if (pos_all_) { - s = slot->db()->BitPos(key_, bit_val_, &pos); + s = slot->db()->BitPos(key_, static_cast(bit_val_), &pos); } else if (!pos_all_ && !endoffset_set_) { - s = slot->db()->BitPos(key_, bit_val_, start_offset_, &pos); + s = slot->db()->BitPos(key_, static_cast(bit_val_), start_offset_, &pos); } else if (!pos_all_ && endoffset_set_) { - s = slot->db()->BitPos(key_, bit_val_, start_offset_, end_offset_, &pos); + s = slot->db()->BitPos(key_, static_cast(bit_val_), start_offset_, end_offset_, &pos); } if (s.ok()) { res_.AppendInteger(static_cast(pos)); diff --git a/src/pika_client_conn.cc b/src/pika_client_conn.cc index 8dab3c8f25..c811c1bc6f 100644 --- a/src/pika_client_conn.cc +++ b/src/pika_client_conn.cc @@ -134,8 +134,8 @@ std::shared_ptr PikaClientConn::DoCmd(const PikaCmdArgsType& argv, const st } void PikaClientConn::ProcessSlowlog(const PikaCmdArgsType& argv, uint64_t start_us, uint64_t do_duration) { - int32_t start_time = start_us / 1000000; - int64_t duration = pstd::NowMicros() - start_us; + auto start_time = static_cast(start_us / 1000000); + auto duration = static_cast(pstd::NowMicros() - start_us); if (duration > g_pika_conf->slowlog_slower_than()) { g_pika_server->SlowlogPushEntry(argv, start_time, duration); if (g_pika_conf->slowlog_write_errorlog()) { @@ -165,7 +165,7 @@ void PikaClientConn::ProcessSlowlog(const PikaCmdArgsType& argv, uint64_t start_ void PikaClientConn::ProcessMonitor(const PikaCmdArgsType& argv) { std::string monitor_message; std::string db_name = current_db_.substr(2); - monitor_message = std::to_string(1.0 * pstd::NowMicros() / 1000000) + " [" + db_name + " " + this->ip_port() + "]"; + monitor_message = std::to_string(1.0 * static_cast(pstd::NowMicros()) / 1000000) + " [" + db_name + " " + this->ip_port() + "]"; for (const auto& iter : argv) { monitor_message += " " + pstd::ToRead(iter); } @@ -240,7 +240,7 @@ void PikaClientConn::DoExecTask(void* arg) { } void PikaClientConn::BatchExecRedisCmd(const std::vector& argvs) { - resp_num.store(argvs.size()); + resp_num.store(static_cast(argvs.size())); for (const auto& argv : argvs) { std::shared_ptr resp_ptr = std::make_shared(); resp_array.push_back(resp_ptr); diff --git a/src/pika_command.cc b/src/pika_command.cc index e83c0df506..2c4aa24c6b 100644 --- a/src/pika_command.cc +++ b/src/pika_command.cc @@ -933,10 +933,10 @@ PikaCmdArgsType& Cmd::argv() { return argv_; } std::string Cmd::ToBinlog(uint32_t exec_time, uint32_t term_id, uint64_t logic_id, uint32_t filenum, uint64_t offset) { std::string content; content.reserve(RAW_ARGS_LEN); - RedisAppendLen(content, argv_.size(), "*"); + RedisAppendLenUint64(content, argv_.size(), "*"); for (const auto& v : argv_) { - RedisAppendLen(content, v.size(), "$"); + RedisAppendLenUint64(content, v.size(), "$"); RedisAppendContent(content, v); } @@ -944,7 +944,7 @@ std::string Cmd::ToBinlog(uint32_t exec_time, uint32_t term_id, uint64_t logic_i content, {}); } -bool Cmd::CheckArg(int num) const { return !((arity_ > 0 && num != arity_) || (arity_ < 0 && num < -arity_)); } +bool Cmd::CheckArg(uint64_t num) const { return !((arity_ > 0 && num != arity_) || (arity_ < 0 && num < -arity_)); } void Cmd::LogCommand() const { std::string command; diff --git a/src/pika_conf.cc b/src/pika_conf.cc index dfc5292f21..b3d8f679af 100644 --- a/src/pika_conf.cc +++ b/src/pika_conf.cc @@ -24,7 +24,7 @@ Status PikaConf::InternalGetTargetDB(const std::string& db_name, uint32_t* const int32_t db_index = -1; for (size_t idx = 0; idx < db_structs_.size(); ++idx) { if (db_structs_[idx].db_name == db_name) { - db_index = idx; + db_index = static_cast(idx); break; } } @@ -309,7 +309,7 @@ int PikaConf::Load() { bool have_week = false; std::string compact_cron; std::string week_str; - int slash_num = count(compact_cron_.begin(), compact_cron_.end(), '/'); + int64_t slash_num = count(compact_cron_.begin(), compact_cron_.end(), '/'); if (slash_num == 2) { have_week = true; std::string::size_type first_slash = compact_cron_.find('/'); @@ -616,7 +616,7 @@ int PikaConf::ConfigRewrite() { SetConfStr("master-run-id", master_run_id_); SetConfInt("max-cache-statistic-keys", max_cache_statistic_keys_); SetConfInt("small-compaction-threshold", small_compaction_threshold_); - SetConfInt("max-client-response-size", max_client_response_size_); + SetConfInt("max-client-response-size", static_cast(max_client_response_size_)); SetConfInt("db-sync-speed", db_sync_speed_); SetConfStr("compact-cron", compact_cron_); SetConfStr("compact-interval", compact_interval_); diff --git a/src/pika_consensus.cc b/src/pika_consensus.cc index c3d000bb9e..72ca296946 100644 --- a/src/pika_consensus.cc +++ b/src/pika_consensus.cc @@ -165,7 +165,7 @@ Status SyncProgress::Update(const std::string& ip, int port, const LogOffset& st int SyncProgress::SlaveSize() { std::shared_lock l(rwlock_); - return slaves_.size(); + return static_cast(slaves_.size()); } LogOffset SyncProgress::InternalCalCommittedIndex(const std::unordered_map& match_index) { @@ -248,7 +248,7 @@ int MemLog::InternalFindLogByLogicIndex(const LogOffset& offset) { return -1; } if (logs_[i].offset.l_offset.index == offset.l_offset.index) { - return i; + return static_cast(i); } } return -1; @@ -260,7 +260,7 @@ int MemLog::InternalFindLogByBinlogOffset(const LogOffset& offset) { return -1; } if (logs_[i].offset == offset) { - return i; + return static_cast(i); } } return -1; @@ -942,7 +942,7 @@ Status ConsensusCoordinator::FollowerNegotiate(const std::vector& hin } LogOffset committed = committed_index(); - for (int i = hints.size() - 1; i >= 0; i--) { + for (size_t i = hints.size() - 1; i >= 0; i--) { if (hints[i].l_offset.index < committed.l_offset.index) { return Status::Corruption("hints less than committed index"); } diff --git a/src/pika_db.cc b/src/pika_db.cc index 5cfeddd6a5..53831d30ba 100644 --- a/src/pika_db.cc +++ b/src/pika_db.cc @@ -162,7 +162,7 @@ void DB::RunKeyScan() { break; } } - key_scan_info_.duration = time(nullptr) - key_scan_info_.start_time; + key_scan_info_.duration = static_cast(time(nullptr) - key_scan_info_.start_time); std::lock_guard lm(key_scan_protector_); if (s.ok()) { @@ -220,7 +220,7 @@ void DB::DoKeyScan(void* arg) { void DB::InitKeyScan() { key_scan_info_.start_time = time(nullptr); char s_time[32]; - int len = strftime(s_time, sizeof(s_time), "%Y-%m-%d %H:%M:%S", localtime(&key_scan_info_.start_time)); + size_t len = strftime(s_time, sizeof(s_time), "%Y-%m-%d %H:%M:%S", localtime(&key_scan_info_.start_time)); key_scan_info_.s_start_time.assign(s_time, len); key_scan_info_.duration = -1; // duration -1 mean the task in processing } diff --git a/src/pika_dispatch_thread.cc b/src/pika_dispatch_thread.cc index 288d7e0757..21842905db 100644 --- a/src/pika_dispatch_thread.cc +++ b/src/pika_dispatch_thread.cc @@ -28,7 +28,7 @@ PikaDispatchThread::~PikaDispatchThread() { int PikaDispatchThread::StartThread() { return thread_rep_->StartThread(); } -int64_t PikaDispatchThread::ThreadClientList(std::vector* clients) { +uint64_t PikaDispatchThread::ThreadClientList(std::vector* clients) { std::vector conns_info = thread_rep_->conns_info(); if (clients) { for (auto& info : conns_info) { diff --git a/src/pika_geo.cc b/src/pika_geo.cc index 0a87696978..78c28f6c6a 100644 --- a/src/pika_geo.cc +++ b/src/pika_geo.cc @@ -79,7 +79,7 @@ void GeoPosCmd::DoInitial() { void GeoPosCmd::Do(std::shared_ptr slot) { double score; - res_.AppendArrayLen(members_.size()); + res_.AppendArrayLenUint64(members_.size()); for (const auto& member : members_) { rocksdb::Status s = slot->db()->ZScore(key_, member, &score); if (s.ok()) { @@ -185,7 +185,7 @@ void GeoDistCmd::Do(std::shared_ptr slot) { distance = length_converter(distance, unit_); char buf[32]; sprintf(buf, "%.4f", distance); - res_.AppendStringLen(strlen(buf)); + res_.AppendStringLenUint64(strlen(buf)); res_.AppendContent(buf); } @@ -204,7 +204,7 @@ void GeoHashCmd::DoInitial() { void GeoHashCmd::Do(std::shared_ptr slot) { const char* geoalphabet = "0123456789bcdefghjkmnpqrstuvwxyz"; - res_.AppendArrayLen(members_.size()); + res_.AppendArrayLenUint64(members_.size()); for (const auto& member : members_) { double score; rocksdb::Status s = slot->db()->ZScore(key_, member, &score); @@ -223,7 +223,7 @@ void GeoHashCmd::Do(std::shared_ptr slot) { char buf[12]; int i; for (i = 0; i < 11; i++) { - int idx = (encode_hash.bits >> (52 - ((i + 1) * 5))) & 0x1f; + uint64_t idx = (encode_hash.bits >> (52 - ((i + 1) * 5))) & 0x1f; buf[i] = geoalphabet[idx]; } buf[11] = '\0'; @@ -282,7 +282,7 @@ static void GetAllNeighbors(const std::shared_ptr& slot, std::string& key, // For each neighbor, get all the matching // members and add them to the potential result list. std::vector result; - int last_processed = 0; + size_t last_processed = 0; for (size_t i = 0; i < sizeof(neighbors) / sizeof(*neighbors); i++) { GeoHashFix52Bits min; GeoHashFix52Bits max; @@ -323,9 +323,9 @@ static void GetAllNeighbors(const std::shared_ptr& slot, std::string& key, // If using the count opiton if (range.count) { - count_limit = static_cast(result.size()) < range.count_limit ? result.size() : range.count_limit; + count_limit = static_cast(result.size() < range.count_limit ? result.size() : range.count_limit); } else { - count_limit = result.size(); + count_limit = static_cast(result.size()); } // If using sort option if (range.sort == Asc) { @@ -360,7 +360,7 @@ static void GetAllNeighbors(const std::shared_ptr& slot, std::string& key, res.AppendArrayLen(range.option_num + 1); } // Member - res.AppendStringLen(result[i].member.size()); + res.AppendStringLenUint64(result[i].member.size()); res.AppendContent(result[i].member); // If using withdist option @@ -372,12 +372,12 @@ static void GetAllNeighbors(const std::shared_ptr& slot, std::string& key, distance = length_converter(distance, range.unit); char buf[32]; sprintf(buf, "%.4f", distance); - res.AppendStringLen(strlen(buf)); + res.AppendStringLenUint64(strlen(buf)); res.AppendContent(buf); } // If using withhash option if (range.withhash) { - res.AppendInteger(result[i].score); + res.AppendInteger(static_cast(result[i].score)); } // If using withcoord option if (range.withcoord) { diff --git a/src/pika_geohash.cc b/src/pika_geohash.cc index 1874acf36a..a59d0cf1cb 100644 --- a/src/pika_geohash.cc +++ b/src/pika_geohash.cc @@ -141,9 +141,9 @@ int geohashEncode(const GeoHashRange* long_range, const GeoHashRange* lat_range, double long_offset = (longitude - long_range->min) / (long_range->max - long_range->min); /* convert to fixed point based on the step size */ - lat_offset *= (1ULL << step); - long_offset *= (1ULL << step); - hash->bits = interleave64(lat_offset, long_offset); + auto lat_offset_step = static_cast(lat_offset * static_cast(1ULL << step)); + auto long_offset_step = static_cast(long_offset * static_cast(1ULL << step)); + hash->bits = interleave64(lat_offset_step, long_offset_step); return 1; } @@ -176,10 +176,10 @@ int geohashDecode(const GeoHashRange long_range, const GeoHashRange lat_range, c /* divide by 2**step. * Then, for 0-1 coordinate, multiply times scale and add to the min to get the absolute coordinate. */ - area->latitude.min = lat_range.min + (ilato * 1.0 / (1ULL << step)) * lat_scale; - area->latitude.max = lat_range.min + ((ilato + 1) * 1.0 / (1ULL << step)) * lat_scale; - area->longitude.min = long_range.min + (ilono * 1.0 / (1ULL << step)) * long_scale; - area->longitude.max = long_range.min + ((ilono + 1) * 1.0 / (1ULL << step)) * long_scale; + area->latitude.min = lat_range.min + (ilato * 1.0 / static_cast(1ULL << step)) * lat_scale; + area->latitude.max = lat_range.min + ((ilato + 1) * 1.0 / static_cast(1ULL << step)) * lat_scale; + area->longitude.min = long_range.min + (ilono * 1.0 / static_cast(1ULL << step)) * long_scale; + area->longitude.max = long_range.min + ((ilono + 1) * 1.0 / static_cast(1ULL << step)) * long_scale; return 1; } diff --git a/src/pika_hash.cc b/src/pika_hash.cc index 9c14939203..e7ec39af66 100644 --- a/src/pika_hash.cc +++ b/src/pika_hash.cc @@ -68,7 +68,7 @@ void HGetCmd::Do(std::shared_ptr slot) { std::string value; rocksdb::Status s = slot->db()->HGet(key_, field_, &value); if (s.ok()) { - res_.AppendStringLen(value.size()); + res_.AppendStringLenUint64(value.size()); res_.AppendContent(value); } else if (s.IsNotFound()) { res_.AppendContent("$-1"); @@ -103,16 +103,16 @@ void HGetallCmd::Do(std::shared_ptr slot) { break; } else { for (const auto& fv : fvs) { - RedisAppendLen(raw, fv.field.size(), "$"); + RedisAppendLenUint64(raw, fv.field.size(), "$"); RedisAppendContent(raw, fv.field); - RedisAppendLen(raw, fv.value.size(), "$"); + RedisAppendLenUint64(raw, fv.value.size(), "$"); RedisAppendContent(raw, fv.value); } if (raw.size() >= raw_limit) { res_.SetRes(CmdRes::kErrOther, "Response exceeds the max-client-response-size limit"); return; } - total_fv += fvs.size(); + total_fv += static_cast(fvs.size()); cursor = next_cursor; } } while (cursor != 0); @@ -187,7 +187,7 @@ void HIncrbyfloatCmd::Do(std::shared_ptr slot) { std::string new_value; rocksdb::Status s = slot->db()->HIncrbyfloat(key_, field_, by_, &new_value); if (s.ok()) { - res_.AppendStringLen(new_value.size()); + res_.AppendStringLenUint64(new_value.size()); res_.AppendContent(new_value); AddSlotKey("h", key_, slot); } else if (s.IsCorruption() && s.ToString() == "Corruption: value is not a vaild float") { @@ -211,7 +211,7 @@ void HKeysCmd::Do(std::shared_ptr slot) { std::vector fields; rocksdb::Status s = slot->db()->HKeys(key_, &fields); if (s.ok() || s.IsNotFound()) { - res_.AppendArrayLen(fields.size()); + res_.AppendArrayLenUint64(fields.size()); for (const auto& field : fields) { res_.AppendString(field); } @@ -254,10 +254,10 @@ void HMgetCmd::Do(std::shared_ptr slot) { std::vector vss; rocksdb::Status s = slot->db()->HMGet(key_, fields_, &vss); if (s.ok() || s.IsNotFound()) { - res_.AppendArrayLen(vss.size()); + res_.AppendArrayLenUint64(vss.size()); for (const auto& vs : vss) { if (vs.status.ok()) { - res_.AppendStringLen(vs.value.size()); + res_.AppendStringLenUint64(vs.value.size()); res_.AppendContent(vs.value); } else { res_.AppendContent("$-1"); @@ -348,9 +348,9 @@ void HValsCmd::Do(std::shared_ptr slot) { std::vector values; rocksdb::Status s = slot->db()->HVals(key_, &values); if (s.ok() || s.IsNotFound()) { - res_.AppendArrayLen(values.size()); + res_.AppendArrayLenUint64(values.size()); for (const auto& value : values) { - res_.AppendStringLen(value.size()); + res_.AppendStringLenUint64(value.size()); res_.AppendContent(value); } } else { @@ -409,7 +409,7 @@ void HScanCmd::Do(std::shared_ptr slot) { res_.AppendStringLen(len); res_.AppendContent(buf); - res_.AppendArrayLen(field_values.size() * 2); + res_.AppendArrayLenUint64(field_values.size() * 2); for (const auto& field_value : field_values) { res_.AppendString(field_value.field); res_.AppendString(field_value.value); @@ -462,10 +462,10 @@ void HScanxCmd::Do(std::shared_ptr slot) { if (s.ok() || s.IsNotFound()) { res_.AppendArrayLen(2); - res_.AppendStringLen(next_field.size()); + res_.AppendStringLenUint64(next_field.size()); res_.AppendContent(next_field); - res_.AppendArrayLen(2 * field_values.size()); + res_.AppendArrayLenUint64(2 * field_values.size()); for (const auto& field_value : field_values) { res_.AppendString(field_value.field); res_.AppendString(field_value.value); @@ -512,13 +512,13 @@ void PKHScanRangeCmd::Do(std::shared_ptr slot) { std::string next_field; std::vector field_values; rocksdb::Status s = - slot->db()->PKHScanRange(key_, field_start_, field_end_, pattern_, limit_, &field_values, &next_field); + slot->db()->PKHScanRange(key_, field_start_, field_end_, pattern_, static_cast(limit_), &field_values, &next_field); if (s.ok() || s.IsNotFound()) { res_.AppendArrayLen(2); res_.AppendString(next_field); - res_.AppendArrayLen(2 * field_values.size()); + res_.AppendArrayLenUint64(2 * field_values.size()); for (const auto& field_value : field_values) { res_.AppendString(field_value.field); res_.AppendString(field_value.value); @@ -565,13 +565,13 @@ void PKHRScanRangeCmd::Do(std::shared_ptr slot) { std::string next_field; std::vector field_values; rocksdb::Status s = - slot->db()->PKHRScanRange(key_, field_start_, field_end_, pattern_, limit_, &field_values, &next_field); + slot->db()->PKHRScanRange(key_, field_start_, field_end_, pattern_, static_cast(limit_), &field_values, &next_field); if (s.ok() || s.IsNotFound()) { res_.AppendArrayLen(2); res_.AppendString(next_field); - res_.AppendArrayLen(2 * field_values.size()); + res_.AppendArrayLenUint64(2 * field_values.size()); for (const auto& field_value : field_values) { res_.AppendString(field_value.field); res_.AppendString(field_value.value); diff --git a/src/pika_kv.cc b/src/pika_kv.cc index 49960b1780..491269df2d 100644 --- a/src/pika_kv.cc +++ b/src/pika_kv.cc @@ -67,16 +67,16 @@ void SetCmd::Do(std::shared_ptr slot) { int32_t res = 1; switch (condition_) { case SetCmd::kXX: - s = slot->db()->Setxx(key_, value_, &res, sec_); + s = slot->db()->Setxx(key_, value_, &res, static_cast(sec_)); break; case SetCmd::kNX: - s = slot->db()->Setnx(key_, value_, &res, sec_); + s = slot->db()->Setnx(key_, value_, &res, static_cast(sec_)); break; case SetCmd::kVX: - s = slot->db()->Setvx(key_, target_, value_, &success_, sec_); + s = slot->db()->Setvx(key_, target_, value_, &success_, static_cast(sec_)); break; case SetCmd::kEXORPX: - s = slot->db()->Setex(key_, value_, sec_); + s = slot->db()->Setex(key_, value_, static_cast(sec_)); break; default: s = slot->db()->Set(key_, value_); @@ -108,20 +108,20 @@ std::string SetCmd::ToBinlog(uint32_t exec_time, uint32_t term_id, uint64_t logi // to pksetexat cmd std::string pksetexat_cmd("pksetexat"); - RedisAppendLen(content, pksetexat_cmd.size(), "$"); + RedisAppendLenUint64(content, pksetexat_cmd.size(), "$"); RedisAppendContent(content, pksetexat_cmd); // key - RedisAppendLen(content, key_.size(), "$"); + RedisAppendLenUint64(content, key_.size(), "$"); RedisAppendContent(content, key_); // time_stamp char buf[100]; - int32_t time_stamp = time(nullptr) + sec_; + auto time_stamp = static_cast(time(nullptr) + sec_); pstd::ll2string(buf, 100, time_stamp); std::string at(buf); - RedisAppendLen(content, at.size(), "$"); + RedisAppendLenUint64(content, at.size(), "$"); RedisAppendContent(content, at); // value - RedisAppendLen(content, value_.size(), "$"); + RedisAppendLenUint64(content, value_.size(), "$"); RedisAppendContent(content, value_); return PikaBinlogTransverter::BinlogEncode(BinlogType::TypeFirst, exec_time, term_id, logic_id, filenum, offset, content, {}); @@ -142,7 +142,7 @@ void GetCmd::Do(std::shared_ptr slot) { std::string value; rocksdb::Status s = slot->db()->Get(key_, &value); if (s.ok()) { - res_.AppendStringLen(value.size()); + res_.AppendStringLenUint64(value.size()); res_.AppendContent(value); } else if (s.IsNotFound()) { res_.AppendStringLen(-1); @@ -260,7 +260,7 @@ void IncrbyfloatCmd::DoInitial() { void IncrbyfloatCmd::Do(std::shared_ptr slot) { rocksdb::Status s = slot->db()->Incrbyfloat(key_, value_, &new_value_); if (s.ok()) { - res_.AppendStringLen(new_value_.size()); + res_.AppendStringLenUint64(new_value_.size()); res_.AppendContent(new_value_); AddSlotKey("k", key_, slot); } else if (s.IsCorruption() && s.ToString() == "Corruption: Value is not a vaild float") { @@ -334,7 +334,7 @@ void GetsetCmd::Do(std::shared_ptr slot) { if (old_value.empty()) { res_.AppendContent("$-1"); } else { - res_.AppendStringLen(old_value.size()); + res_.AppendStringLenUint64(old_value.size()); res_.AppendContent(old_value); } AddSlotKey("k", key_, slot); @@ -377,10 +377,10 @@ void MgetCmd::Do(std::shared_ptr slot) { std::vector vss; rocksdb::Status s = slot->db()->MGet(keys_, &vss); if (s.ok()) { - res_.AppendArrayLen(vss.size()); + res_.AppendArrayLenUint64(vss.size()); for (const auto& vs : vss) { if (vs.status.ok()) { - res_.AppendStringLen(vs.value.size()); + res_.AppendStringLenUint64(vs.value.size()); res_.AppendContent(vs.value); } else { res_.AppendContent("$-1"); @@ -409,10 +409,10 @@ void MgetCmd::Split(std::shared_ptr slot, const HintKeys& hint_keys) { } void MgetCmd::Merge() { - res_.AppendArrayLen(split_res_.size()); + res_.AppendArrayLenUint64(split_res_.size()); for (const auto& vs : split_res_) { if (vs.status.ok()) { - res_.AppendStringLen(vs.value.size()); + res_.AppendStringLenUint64(vs.value.size()); res_.AppendContent(vs.value); } else { res_.AppendContent("$-1"); @@ -456,14 +456,14 @@ void KeysCmd::Do(std::shared_ptr slot) { keys.clear(); cursor = slot->db()->Scan(type_, cursor, pattern_, PIKA_SCAN_STEP_LENGTH, &keys); for (const auto& key : keys) { - RedisAppendLen(raw, key.size(), "$"); + RedisAppendLenUint64(raw, key.size(), "$"); RedisAppendContent(raw, key); } if (raw.size() >= raw_limit) { res_.SetRes(CmdRes::kErrOther, "Response exceeds the max-client-response-size limit"); return; } - total_key += keys.size(); + total_key += static_cast(keys.size()); } while (cursor != 0); res_.AppendArrayLen(total_key); @@ -499,13 +499,13 @@ std::string SetnxCmd::ToBinlog(uint32_t exec_time, uint32_t term_id, uint64_t lo // don't check variable 'success_', because if 'success_' was false, an empty binlog will be saved into file. // to setnx cmd std::string set_cmd("setnx"); - RedisAppendLen(content, set_cmd.size(), "$"); + RedisAppendLenUint64(content, set_cmd.size(), "$"); RedisAppendContent(content, set_cmd); // key - RedisAppendLen(content, key_.size(), "$"); + RedisAppendLenUint64(content, key_.size(), "$"); RedisAppendContent(content, key_); // value - RedisAppendLen(content, value_.size(), "$"); + RedisAppendLenUint64(content, value_.size(), "$"); RedisAppendContent(content, value_); return PikaBinlogTransverter::BinlogEncode(BinlogType::TypeFirst, exec_time, term_id, logic_id, filenum, offset, @@ -526,7 +526,7 @@ void SetexCmd::DoInitial() { } void SetexCmd::Do(std::shared_ptr slot) { - rocksdb::Status s = slot->db()->Setex(key_, value_, sec_); + rocksdb::Status s = slot->db()->Setex(key_, value_, static_cast(sec_)); if (s.ok()) { res_.SetRes(CmdRes::kOk); AddSlotKey("k", key_, slot); @@ -543,20 +543,20 @@ std::string SetexCmd::ToBinlog(uint32_t exec_time, uint32_t term_id, uint64_t lo // to pksetexat cmd std::string pksetexat_cmd("pksetexat"); - RedisAppendLen(content, pksetexat_cmd.size(), "$"); + RedisAppendLenUint64(content, pksetexat_cmd.size(), "$"); RedisAppendContent(content, pksetexat_cmd); // key - RedisAppendLen(content, key_.size(), "$"); + RedisAppendLenUint64(content, key_.size(), "$"); RedisAppendContent(content, key_); // time_stamp char buf[100]; - int32_t time_stamp = time(nullptr) + sec_; + auto time_stamp = static_cast(time(nullptr) + sec_); pstd::ll2string(buf, 100, time_stamp); std::string at(buf); - RedisAppendLen(content, at.size(), "$"); + RedisAppendLenUint64(content, at.size(), "$"); RedisAppendContent(content, at); // value - RedisAppendLen(content, value_.size(), "$"); + RedisAppendLenUint64(content, value_.size(), "$"); RedisAppendContent(content, value_); return PikaBinlogTransverter::BinlogEncode(BinlogType::TypeFirst, exec_time, term_id, logic_id, filenum, offset, content, {}); @@ -576,7 +576,7 @@ void PsetexCmd::DoInitial() { } void PsetexCmd::Do(std::shared_ptr slot) { - rocksdb::Status s = slot->db()->Setex(key_, value_, usec_ / 1000); + rocksdb::Status s = slot->db()->Setex(key_, value_, static_cast(usec_ / 1000)); if (s.ok()) { res_.SetRes(CmdRes::kOk); } else { @@ -592,20 +592,20 @@ std::string PsetexCmd::ToBinlog(uint32_t exec_time, uint32_t term_id, uint64_t l // to pksetexat cmd std::string pksetexat_cmd("pksetexat"); - RedisAppendLen(content, pksetexat_cmd.size(), "$"); + RedisAppendLenUint64(content, pksetexat_cmd.size(), "$"); RedisAppendContent(content, pksetexat_cmd); // key - RedisAppendLen(content, key_.size(), "$"); + RedisAppendLenUint64(content, key_.size(), "$"); RedisAppendContent(content, key_); // time_stamp char buf[100]; - int32_t time_stamp = time(nullptr) + usec_ / 1000; + auto time_stamp = static_cast(time(nullptr) + usec_ / 1000); pstd::ll2string(buf, 100, time_stamp); std::string at(buf); - RedisAppendLen(content, at.size(), "$"); + RedisAppendLenUint64(content, at.size(), "$"); RedisAppendContent(content, at); // value - RedisAppendLen(content, value_.size(), "$"); + RedisAppendLenUint64(content, value_.size(), "$"); RedisAppendContent(content, value_); return PikaBinlogTransverter::BinlogEncode(BinlogType::TypeFirst, exec_time, term_id, logic_id, filenum, offset, content, {}); @@ -766,7 +766,7 @@ void GetrangeCmd::Do(std::shared_ptr slot) { std::string substr; rocksdb::Status s = slot->db()->Getrange(key_, start_, end_, &substr); if (s.ok() || s.IsNotFound()) { - res_.AppendStringLen(substr.size()); + res_.AppendStringLenUint64(substr.size()); res_.AppendContent(substr); } else { res_.SetRes(CmdRes::kErrOther, s.ToString()); @@ -860,7 +860,7 @@ void ExpireCmd::DoInitial() { void ExpireCmd::Do(std::shared_ptr slot) { std::map type_status; - int64_t res = slot->db()->Expire(key_, sec_, &type_status); + int64_t res = slot->db()->Expire(key_, static_cast(sec_), &type_status); if (res != -1) { res_.AppendInteger(res); } else { @@ -876,17 +876,17 @@ std::string ExpireCmd::ToBinlog(uint32_t exec_time, uint32_t term_id, uint64_t l // to expireat cmd std::string expireat_cmd("expireat"); - RedisAppendLen(content, expireat_cmd.size(), "$"); + RedisAppendLenUint64(content, expireat_cmd.size(), "$"); RedisAppendContent(content, expireat_cmd); // key - RedisAppendLen(content, key_.size(), "$"); + RedisAppendLenUint64(content, key_.size(), "$"); RedisAppendContent(content, key_); // sec char buf[100]; int64_t expireat = time(nullptr) + sec_; pstd::ll2string(buf, 100, expireat); std::string at(buf); - RedisAppendLen(content, at.size(), "$"); + RedisAppendLenUint64(content, at.size(), "$"); RedisAppendContent(content, at); return PikaBinlogTransverter::BinlogEncode(BinlogType::TypeFirst, exec_time, term_id, logic_id, filenum, offset, @@ -907,7 +907,7 @@ void PexpireCmd::DoInitial() { void PexpireCmd::Do(std::shared_ptr slot) { std::map type_status; - int64_t res = slot->db()->Expire(key_, msec_ / 1000, &type_status); + int64_t res = slot->db()->Expire(key_, static_cast(msec_ / 1000), &type_status); if (res != -1) { res_.AppendInteger(res); } else { @@ -919,21 +919,21 @@ std::string PexpireCmd::ToBinlog(uint32_t exec_time, uint32_t term_id, uint64_t uint64_t offset) { std::string content; content.reserve(RAW_ARGS_LEN); - RedisAppendLen(content, argv_.size(), "*"); + RedisAppendLenUint64(content, argv_.size(), "*"); // to expireat cmd std::string expireat_cmd("expireat"); - RedisAppendLen(content, expireat_cmd.size(), "$"); + RedisAppendLenUint64(content, expireat_cmd.size(), "$"); RedisAppendContent(content, expireat_cmd); // key - RedisAppendLen(content, key_.size(), "$"); + RedisAppendLenUint64(content, key_.size(), "$"); RedisAppendContent(content, key_); // sec char buf[100]; int64_t expireat = time(nullptr) + msec_ / 1000; pstd::ll2string(buf, 100, expireat); std::string at(buf); - RedisAppendLen(content, at.size(), "$"); + RedisAppendLenUint64(content, at.size(), "$"); RedisAppendContent(content, at); return PikaBinlogTransverter::BinlogEncode(BinlogType::TypeFirst, exec_time, term_id, logic_id, filenum, offset, @@ -954,7 +954,7 @@ void ExpireatCmd::DoInitial() { void ExpireatCmd::Do(std::shared_ptr slot) { std::map type_status; - int32_t res = slot->db()->Expireat(key_, time_stamp_, &type_status); + int32_t res = slot->db()->Expireat(key_, static_cast(time_stamp_), &type_status); if (res != -1) { res_.AppendInteger(res); } else { @@ -978,21 +978,21 @@ std::string PexpireatCmd::ToBinlog(uint32_t exec_time, uint32_t term_id, uint64_ uint64_t offset) { std::string content; content.reserve(RAW_ARGS_LEN); - RedisAppendLen(content, argv_.size(), "*"); + RedisAppendLenUint64(content, argv_.size(), "*"); // to expireat cmd std::string expireat_cmd("expireat"); - RedisAppendLen(content, expireat_cmd.size(), "$"); + RedisAppendLenUint64(content, expireat_cmd.size(), "$"); RedisAppendContent(content, expireat_cmd); // key - RedisAppendLen(content, key_.size(), "$"); + RedisAppendLenUint64(content, key_.size(), "$"); RedisAppendContent(content, key_); // sec char buf[100]; int64_t expireat = time_stamp_ms_ / 1000; pstd::ll2string(buf, 100, expireat); std::string at(buf); - RedisAppendLen(content, at.size(), "$"); + RedisAppendLenUint64(content, at.size(), "$"); RedisAppendContent(content, at); return PikaBinlogTransverter::BinlogEncode(BinlogType::TypeFirst, exec_time, term_id, logic_id, filenum, offset, @@ -1001,7 +1001,7 @@ std::string PexpireatCmd::ToBinlog(uint32_t exec_time, uint32_t term_id, uint64_ void PexpireatCmd::Do(std::shared_ptr slot) { std::map type_status; - int32_t res = slot->db()->Expireat(key_, time_stamp_ms_ / 1000, &type_status); + int32_t res = slot->db()->Expireat(key_, static_cast(time_stamp_ms_ / 1000), &type_status); if (res != -1) { res_.AppendInteger(res); } else { @@ -1148,9 +1148,9 @@ void PTypeCmd::Do(std::shared_ptr slot) { rocksdb::Status s = slot->db()->GetType(key_, false, types); if (s.ok()) { - res_.AppendArrayLen(types.size()); + res_.AppendArrayLenUint64(types.size()); for (const auto& vs : types) { - res_.AppendStringLen(vs.size()); + res_.AppendStringLenUint64(vs.size()); res_.AppendContent(vs); } } else { @@ -1223,14 +1223,14 @@ void ScanCmd::Do(std::shared_ptr slot) { left = left > PIKA_SCAN_STEP_LENGTH ? left - PIKA_SCAN_STEP_LENGTH : 0; cursor_ret = slot->db()->Scan(type_, cursor_ret, pattern_, batch_count, &keys); for (const auto& key : keys) { - RedisAppendLen(raw, key.size(), "$"); + RedisAppendLenUint64(raw, key.size(), "$"); RedisAppendContent(raw, key); } if (raw.size() >= raw_limit) { res_.SetRes(CmdRes::kErrOther, "Response exceeds the max-client-response-size limit"); return; } - total_key += keys.size(); + total_key += static_cast(keys.size()); } while (cursor_ret != 0 && (left != 0)); res_.AppendArrayLen(2); @@ -1296,10 +1296,10 @@ void ScanxCmd::Do(std::shared_ptr slot) { if (s.ok()) { res_.AppendArrayLen(2); - res_.AppendStringLen(next_key.size()); + res_.AppendStringLenUint64(next_key.size()); res_.AppendContent(next_key); - res_.AppendArrayLen(keys.size()); + res_.AppendArrayLenUint64(keys.size()); std::vector::iterator iter; for (const auto& key : keys) { res_.AppendString(key); @@ -1323,7 +1323,7 @@ void PKSetexAtCmd::DoInitial() { } void PKSetexAtCmd::Do(std::shared_ptr slot) { - rocksdb::Status s = slot->db()->PKSetexAt(key_, value_, time_stamp_); + rocksdb::Status s = slot->db()->PKSetexAt(key_, value_, static_cast(time_stamp_)); if (s.ok()) { res_.SetRes(CmdRes::kOk); } else { @@ -1389,15 +1389,15 @@ void PKScanRangeCmd::Do(std::shared_ptr slot) { std::string next_key; std::vector keys; std::vector kvs; - rocksdb::Status s = slot->db()->PKScanRange(type_, key_start_, key_end_, pattern_, limit_, &keys, &kvs, &next_key); + rocksdb::Status s = slot->db()->PKScanRange(type_, key_start_, key_end_, pattern_, static_cast(limit_), &keys, &kvs, &next_key); if (s.ok()) { res_.AppendArrayLen(2); - res_.AppendStringLen(next_key.size()); + res_.AppendStringLenUint64(next_key.size()); res_.AppendContent(next_key); if (type_ == storage::kStrings) { - res_.AppendArrayLen(string_with_value ? 2 * kvs.size() : kvs.size()); + res_.AppendArrayLenUint64(string_with_value ? 2 * kvs.size() : kvs.size()); for (const auto& kv : kvs) { res_.AppendString(kv.key); if (string_with_value) { @@ -1405,7 +1405,7 @@ void PKScanRangeCmd::Do(std::shared_ptr slot) { } } } else { - res_.AppendArrayLen(keys.size()); + res_.AppendArrayLenUint64(keys.size()); for (const auto& key : keys) { res_.AppendString(key); } @@ -1473,15 +1473,16 @@ void PKRScanRangeCmd::Do(std::shared_ptr slot) { std::string next_key; std::vector keys; std::vector kvs; - rocksdb::Status s = slot->db()->PKRScanRange(type_, key_start_, key_end_, pattern_, limit_, &keys, &kvs, &next_key); + rocksdb::Status s = slot->db()->PKRScanRange(type_, key_start_, key_end_, pattern_, static_cast(limit_), + &keys, &kvs, &next_key); if (s.ok()) { res_.AppendArrayLen(2); - res_.AppendStringLen(next_key.size()); + res_.AppendStringLenUint64(next_key.size()); res_.AppendContent(next_key); if (type_ == storage::kStrings) { - res_.AppendArrayLen(string_with_value ? 2 * kvs.size() : kvs.size()); + res_.AppendArrayLenUint64(string_with_value ? 2 * kvs.size() : kvs.size()); for (const auto& kv : kvs) { res_.AppendString(kv.key); if (string_with_value) { @@ -1489,7 +1490,7 @@ void PKRScanRangeCmd::Do(std::shared_ptr slot) { } } } else { - res_.AppendArrayLen(keys.size()); + res_.AppendArrayLenUint64(keys.size()); for (const auto& key : keys) { res_.AppendString(key); } diff --git a/src/pika_list.cc b/src/pika_list.cc index e303c70ab3..ef91a34f44 100644 --- a/src/pika_list.cc +++ b/src/pika_list.cc @@ -71,7 +71,7 @@ void LLenCmd::Do(std::shared_ptr slot) { uint64_t llen = 0; rocksdb::Status s = slot->db()->LLen(key_, &llen); if (s.ok() || s.IsNotFound()) { - res_.AppendInteger(llen); + res_.AppendInteger(static_cast(llen)); } else { res_.SetRes(CmdRes::kErrOther, s.ToString()); } @@ -92,7 +92,7 @@ void LPushCmd::Do(std::shared_ptr slot) { uint64_t llen = 0; rocksdb::Status s = slot->db()->LPush(key_, values_, &llen); if (s.ok()) { - res_.AppendInteger(llen); + res_.AppendInteger(static_cast(llen)); AddSlotKey("l", key_, slot); } else { res_.SetRes(CmdRes::kErrOther, s.ToString()); @@ -122,7 +122,7 @@ void LPopCmd::Do(std::shared_ptr slot) { std::vector elements; rocksdb::Status s = slot->db()->LPop(key_, count_, &elements); if (s.ok()) { - res_.AppendArrayLen(elements.size()); + res_.AppendArrayLenUint64(elements.size()); for (const auto& element : elements) { res_.AppendString(element); } @@ -148,7 +148,7 @@ void LPushxCmd::Do(std::shared_ptr slot) { uint64_t llen = 0; rocksdb::Status s = slot->db()->LPushx(key_, values_, &llen); if (s.ok() || s.IsNotFound()) { - res_.AppendInteger(llen); + res_.AppendInteger(static_cast(llen)); AddSlotKey("l", key_, slot); } else { res_.SetRes(CmdRes::kErrOther, s.ToString()); @@ -175,7 +175,7 @@ void LRangeCmd::Do(std::shared_ptr slot) { std::vector values; rocksdb::Status s = slot->db()->LRange(key_, left_, right_, &values); if (s.ok()) { - res_.AppendArrayLen(values.size()); + res_.AppendArrayLenUint64(values.size()); for (const auto& value : values) { res_.AppendString(value); } @@ -203,7 +203,7 @@ void LRemCmd::Do(std::shared_ptr slot) { uint64_t res = 0; rocksdb::Status s = slot->db()->LRem(key_, count_, value_, &res); if (s.ok() || s.IsNotFound()) { - res_.AppendInteger(res); + res_.AppendInteger(static_cast(res)); } else { res_.SetRes(CmdRes::kErrOther, s.ToString()); } @@ -284,7 +284,7 @@ void RPopCmd::Do(std::shared_ptr slot) { std::vector elements; rocksdb::Status s = slot->db()->RPop(key_, count_, &elements); if (s.ok()) { - res_.AppendArrayLen(elements.size()); + res_.AppendArrayLenUint64(elements.size()); for (const auto& element : elements) { res_.AppendString(element); } @@ -362,7 +362,7 @@ void RPushCmd::Do(std::shared_ptr slot) { uint64_t llen = 0; rocksdb::Status s = slot->db()->RPush(key_, values_, &llen); if (s.ok()) { - res_.AppendInteger(llen); + res_.AppendInteger(static_cast(llen)); AddSlotKey("l", key_, slot); } else { res_.SetRes(CmdRes::kErrOther, s.ToString()); @@ -384,7 +384,7 @@ void RPushxCmd::Do(std::shared_ptr slot) { uint64_t llen = 0; rocksdb::Status s = slot->db()->RPushx(key_, values_, &llen); if (s.ok() || s.IsNotFound()) { - res_.AppendInteger(llen); + res_.AppendInteger(static_cast(llen)); AddSlotKey("l", key_, slot); } else { res_.SetRes(CmdRes::kErrOther, s.ToString()); diff --git a/src/pika_meta.cc b/src/pika_meta.cc index 6b4311597e..664b43e662 100644 --- a/src/pika_meta.cc +++ b/src/pika_meta.cc @@ -96,7 +96,7 @@ Status PikaMeta::ParseMeta(std::vector* const db_structs) { memcpy(buf, reader->GetData() + 2 * sizeof(uint32_t), meta_size); InnerMessage::PikaMeta meta; - if (!meta.ParseFromArray(buf, meta_size)) { + if (!meta.ParseFromArray(buf, static_cast(meta_size))) { LOG(WARNING) << "Parse meta string failed"; return Status::Corruption("parse meta string failed"); } diff --git a/src/pika_migrate_thread.cc b/src/pika_migrate_thread.cc index dfcbe4d509..5dc5884608 100644 --- a/src/pika_migrate_thread.cc +++ b/src/pika_migrate_thread.cc @@ -352,14 +352,14 @@ bool PikaParseSendThread::Init(const std::string &ip, int64_t port, int64_t time dest_ip_ = ip; dest_port_ = port; timeout_ms_ = timeout_ms; - mgrtkeys_num_ = mgrtkeys_num; + mgrtkeys_num_ = static_cast(mgrtkeys_num); cli_ = net::NewRedisCli(); - cli_->set_connect_timeout(timeout_ms_); - cli_->set_send_timeout(timeout_ms_); - cli_->set_recv_timeout(timeout_ms_); + cli_->set_connect_timeout(static_cast(timeout_ms_)); + cli_->set_send_timeout(static_cast(timeout_ms_)); + cli_->set_recv_timeout(static_cast(timeout_ms_)); LOG(INFO) << "PikaParseSendThread init cli_, dest_ip_: " << dest_ip_ << " ,dest_port_: " << dest_port_; - pstd::Status result = cli_->Connect(dest_ip_, dest_port_, g_pika_server->host()); + pstd::Status result = cli_->Connect(dest_ip_, static_cast(dest_port_), g_pika_server->host()); if (!result.ok()) { LOG(ERROR) << "PikaParseSendThread::Init failed. Connect server(" << dest_ip_ << ":" << dest_port_ << ") " << result.ToString(); @@ -680,8 +680,8 @@ void PikaMigrateThread::GetMigrateStatus(std::string *ip, int64_t *port, int64_t *migrating = is_migrating_; *moved = moved_num_; std::unique_lock lq(mgrtkeys_queue_mutex_); - int64_t migrating_keys_num = mgrtkeys_queue_.size(); - std::string slotKey = GetSlotKey(slot_id_); + int64_t migrating_keys_num = static_cast(mgrtkeys_queue_.size()); + std::string slotKey = GetSlotKey(static_cast(slot_id_)); int32_t slot_size = 0; rocksdb::Status s = slot_->db()->SCard(slotKey, &slot_size); if (s.ok()) { @@ -803,7 +803,7 @@ void PikaMigrateThread::ReadSlotKeys(const std::string &slotKey, int64_t need_re } bool PikaMigrateThread::CreateParseSendThreads(int32_t dispatch_num) { - workers_num_ = g_pika_conf->slotmigrate_thread_num(); + workers_num_ = static_cast(g_pika_conf->slotmigrate_thread_num()); for (int32_t i = 0; i < workers_num_; ++i) { auto worker = new PikaParseSendThread(this, slot_); if (!worker->Init(dest_ip_, dest_port_, timeout_ms_, dispatch_num)) { @@ -847,14 +847,14 @@ void *PikaMigrateThread::ThreadMain() { LOG(INFO) << "PikaMigrateThread::ThreadMain Start"; // Create parse_send_threads - int32_t dispatch_num = g_pika_conf->thread_migrate_keys_num(); + auto dispatch_num = static_cast(g_pika_conf->thread_migrate_keys_num()); if (!CreateParseSendThreads(dispatch_num)) { LOG(INFO) << "PikaMigrateThread::ThreadMain CreateParseSendThreads failed !!!"; DestroyThread(true); return nullptr; } - std::string slotKey = GetSlotKey(slot_id_); + std::string slotKey = GetSlotKey(static_cast(slot_id_)); int32_t slot_size = 0; slot_->db()->SCard(slotKey, &slot_size); @@ -897,7 +897,7 @@ void *PikaMigrateThread::ThreadMain() { int64_t need_read_num = (0 < round_remained_keys - dispatch_num) ? dispatch_num : round_remained_keys; ReadSlotKeys(slotKey, need_read_num, real_read_num, &is_finish); round_remained_keys -= need_read_num; - send_num_ += real_read_num; + send_num_ += static_cast(real_read_num); } mgrtkeys_cond_.notify_all(); diff --git a/src/pika_monitor_thread.cc b/src/pika_monitor_thread.cc index 5943745319..672f9cd94a 100644 --- a/src/pika_monitor_thread.cc +++ b/src/pika_monitor_thread.cc @@ -67,7 +67,7 @@ int32_t PikaMonitorThread::ThreadClientList(std::vector* clients_ptr clients_ptr->push_back(monitor_client); } } - return monitor_clients_.size(); + return static_cast(monitor_clients_.size()); } void PikaMonitorThread::AddCronTask(const MonitorCronTask& task) { @@ -107,9 +107,9 @@ bool PikaMonitorThread::HasMonitorClients() { return has_monitor_clients_.load() net::WriteStatus PikaMonitorThread::SendMessage(int32_t fd, std::string& message) { size_t retry = 0; - ssize_t nwritten = 0; - ssize_t message_len_sended = 0; - ssize_t message_len_left = message.size(); + size_t nwritten = 0; + size_t message_len_sended = 0; + size_t message_len_left = message.size(); while (message_len_left > 0) { nwritten = write(fd, message.data() + message_len_sended, message_len_left); if (nwritten == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) { diff --git a/src/pika_pubsub.cc b/src/pika_pubsub.cc index 4808b9ef69..46e134ff4b 100644 --- a/src/pika_pubsub.cc +++ b/src/pika_pubsub.cc @@ -225,17 +225,17 @@ void PubSubCmd::Do(std::shared_ptr slot) { } g_pika_server->PubSubChannels(pattern, &result); - res_.AppendArrayLen(result.size()); + res_.AppendArrayLenUint64(result.size()); for (auto &it : result) { - res_.AppendStringLen(it.length()); + res_.AppendStringLenUint64(it.length()); res_.AppendContent(it); } } else if (strcasecmp(subcommand_.data(), "numsub") == 0) { std::vector> result; g_pika_server->PubSubNumSub(arguments_, &result); - res_.AppendArrayLen(result.size() * 2); + res_.AppendArrayLenUint64(result.size() * 2); for (auto &it : result) { - res_.AppendStringLen(it.first.length()); + res_.AppendStringLenUint64(it.first.length()); res_.AppendContent(it.first); res_.AppendInteger(it.second); } diff --git a/src/pika_repl_bgworker.cc b/src/pika_repl_bgworker.cc index fab9c51401..a74ad24d46 100644 --- a/src/pika_repl_bgworker.cc +++ b/src/pika_repl_bgworker.cc @@ -75,7 +75,7 @@ void PikaReplBgWorker::HandleBGWorkerWriteBinlog(void* arg) { } // find the last not keepalive binlogsync - for (int i = index->size() - 1; i >= 0; i--) { + for (int i = static_cast(index->size() - 1); i >= 0; i--) { const InnerMessage::InnerResponse::BinlogSync& binlog_res = res->binlog_sync((*index)[i]); if (!binlog_res.binlog().empty()) { ParseBinlogOffset(binlog_res.binlog_offset(), &pb_end); @@ -211,7 +211,7 @@ int PikaReplBgWorker::HandleWriteBinlog(net::RedisParser* parser, const net::Red if (g_pika_server->HasMonitorClients()) { std::string db_name = worker->db_name_.substr(2); std::string monitor_message = - std::to_string(1.0 * pstd::NowMicros() / 1000000) + " [" + db_name + " " + worker->ip_port_ + "]"; + std::to_string(static_cast(pstd::NowMicros()) / 1000000) + " [" + db_name + " " + worker->ip_port_ + "]"; for (const auto& item : argv) { monitor_message += " " + pstd::ToRead(item); } @@ -267,8 +267,8 @@ void PikaReplBgWorker::HandleBGWorkerWriteDB(void* arg) { } if (g_pika_conf->slowlog_slower_than() >= 0) { - int32_t start_time = start_us / 1000000; - int64_t duration = pstd::NowMicros() - start_us; + auto start_time = static_cast(start_us / 1000000); + auto duration = static_cast(pstd::NowMicros() - start_us); if (duration > g_pika_conf->slowlog_slower_than()) { g_pika_server->SlowlogPushEntry(argv, start_time, duration); if (g_pika_conf->slowlog_write_errorlog()) { diff --git a/src/pika_repl_client.cc b/src/pika_repl_client.cc index de48b99776..3927d770b2 100644 --- a/src/pika_repl_client.cc +++ b/src/pika_repl_client.cc @@ -161,7 +161,7 @@ Status PikaReplClient::SendSlotDBSync(const std::string& ip, uint32_t port, cons LOG(WARNING) << "Serialize Slot DBSync Request Failed, to Master (" << ip << ":" << port << ")"; return Status::Corruption("Serialize Failed"); } - return client_thread_->Write(ip, port + kPortShiftReplServer, to_send); + return client_thread_->Write(ip, static_cast(port) + kPortShiftReplServer, to_send); } Status PikaReplClient::SendSlotTrySync(const std::string& ip, uint32_t port, const std::string& db_name, @@ -207,7 +207,7 @@ Status PikaReplClient::SendSlotTrySync(const std::string& ip, uint32_t port, con LOG(WARNING) << "Serialize Slot TrySync Request Failed, to Master (" << ip << ":" << port << ")"; return Status::Corruption("Serialize Failed"); } - return client_thread_->Write(ip, port + kPortShiftReplServer, to_send); + return client_thread_->Write(ip, static_cast(port + kPortShiftReplServer), to_send); } Status PikaReplClient::SendSlotBinlogSync(const std::string& ip, uint32_t port, const std::string& db_name, @@ -250,7 +250,7 @@ Status PikaReplClient::SendSlotBinlogSync(const std::string& ip, uint32_t port, LOG(WARNING) << "Serialize Slot BinlogSync Request Failed, to Master (" << ip << ":" << port << ")"; return Status::Corruption("Serialize Failed"); } - return client_thread_->Write(ip, port + kPortShiftReplServer, to_send); + return client_thread_->Write(ip, static_cast(port + kPortShiftReplServer), to_send); } Status PikaReplClient::SendRemoveSlaveNode(const std::string& ip, uint32_t port, const std::string& db_name, @@ -272,5 +272,5 @@ Status PikaReplClient::SendRemoveSlaveNode(const std::string& ip, uint32_t port, << slot_id; return Status::Corruption("Serialize Failed"); } - return client_thread_->Write(ip, port + kPortShiftReplServer, to_send); + return client_thread_->Write(ip, static_cast(port + kPortShiftReplServer), to_send); } diff --git a/src/pika_repl_client_conn.cc b/src/pika_repl_client_conn.cc index 5a8a846776..3db4ad478a 100644 --- a/src/pika_repl_client_conn.cc +++ b/src/pika_repl_client_conn.cc @@ -38,7 +38,7 @@ bool PikaReplClientConn::IsDBStructConsistent(const std::vector& curre int PikaReplClientConn::DealMessage() { std::shared_ptr response = std::make_shared(); - ::google::protobuf::io::ArrayInputStream input(rbuf_ + cur_pos_ - header_len_, header_len_); + ::google::protobuf::io::ArrayInputStream input(rbuf_ + cur_pos_ - header_len_, static_cast(header_len_)); ::google::protobuf::io::CodedInputStream decoder(&input); decoder.SetTotalBytesLimit(g_pika_conf->max_conn_rbuf_size()); bool success = response->ParseFromCodedStream(&decoder) && decoder.ConsumedEntireMessage(); diff --git a/src/pika_repl_server_conn.cc b/src/pika_repl_server_conn.cc index 330ec60516..09cf95ce00 100644 --- a/src/pika_repl_server_conn.cc +++ b/src/pika_repl_server_conn.cc @@ -52,7 +52,7 @@ void PikaReplServerConn::HandleMetaSyncRequest(void* arg) { for (const auto& db_struct : db_structs) { InnerMessage::InnerResponse_MetaSync_DBInfo* db_info = meta_sync->add_dbs_info(); db_info->set_db_name(db_struct.db_name); - db_info->set_slot_num(db_struct.slot_num); + db_info->set_slot_num(static_cast(db_struct.slot_num)); } } } @@ -342,7 +342,8 @@ void PikaReplServerConn::HandleDBSyncRequest(void* arg) { } } - g_pika_server->TryDBSync(node.ip(), node.port() + kPortShiftRSync, db_name, slot_id, slave_boffset.filenum()); + g_pika_server->TryDBSync(node.ip(), node.port() + kPortShiftRSync, db_name, slot_id, + static_cast(slave_boffset.filenum())); std::string reply_str; if (!response.SerializeToString(&reply_str) || (conn->WriteResp(reply_str) != 0)) { @@ -491,7 +492,7 @@ void PikaReplServerConn::HandleRemoveSlaveNodeRequest(void* arg) { int PikaReplServerConn::DealMessage() { std::shared_ptr req = std::make_shared(); - bool parse_res = req->ParseFromArray(rbuf_ + cur_pos_ - header_len_, header_len_); + bool parse_res = req->ParseFromArray(rbuf_ + cur_pos_ - header_len_, static_cast(header_len_)); if (!parse_res) { LOG(WARNING) << "Pika repl server connection pb parse error."; return -1; diff --git a/src/pika_rm.cc b/src/pika_rm.cc index 7af72c97a8..b46de79f2c 100644 --- a/src/pika_rm.cc +++ b/src/pika_rm.cc @@ -722,7 +722,7 @@ int PikaReplicaManager::ConsumeWriteQueue() { } size_t batch_index = queue.size() > kBinlogSendBatchNum ? kBinlogSendBatchNum : queue.size(); std::vector to_send; - int batch_size = 0; + size_t batch_size = 0; for (size_t i = 0; i < batch_index; ++i) { WriteTask& task = queue.front(); batch_size += task.binlog_chip_.binlog_.size(); diff --git a/src/pika_server.cc b/src/pika_server.cc index 3759190c57..eb2465df89 100644 --- a/src/pika_server.cc +++ b/src/pika_server.cc @@ -169,7 +169,7 @@ void PikaServer::Start() { std::string slaveof = g_pika_conf->slaveof(); if (!slaveof.empty()) { - int32_t sep = slaveof.find(':'); + auto sep = static_cast(slaveof.find(':')); std::string master_ip = slaveof.substr(0, sep); int32_t master_port = std::stoi(slaveof.substr(sep + 1)); if ((master_ip == "127.0.0.1" || master_ip == host_) && master_port == port_) { @@ -622,7 +622,7 @@ void PikaServer::DeleteSlave(int fd) { } iter++; } - slave_num = slaves_.size(); + slave_num = static_cast(slaves_.size()); } if (is_find) { @@ -639,7 +639,7 @@ void PikaServer::DeleteSlave(int fd) { int32_t PikaServer::CountSyncSlaves() { std::lock_guard ldb(db_sync_protector_); - return db_sync_slaves_.size(); + return static_cast(db_sync_slaves_.size()); } int32_t PikaServer::GetShardingSlaveListString(std::string& slave_list_str) { @@ -656,7 +656,7 @@ int32_t PikaServer::GetShardingSlaveListString(std::string& slave_list_str) { tmp_stream << "slave" << index++ << ":ip=" << ip << ",port=" << port << "\r\n"; } slave_list_str.assign(tmp_stream.str()); - return index; + return static_cast(index); } int32_t PikaServer::GetSlaveListString(std::string& slave_list_str) { @@ -699,14 +699,14 @@ int32_t PikaServer::GetSlaveListString(std::string& slave_list_str) { tmp_stream << "\r\n"; } slave_list_str.assign(tmp_stream.str()); - return index; + return static_cast(index); } // Try add Slave, return true if success, // return false when slave already exist bool PikaServer::TryAddSlave(const std::string& ip, int64_t port, int fd, const std::vector& db_structs) { - std::string ip_port = pstd::IpPortString(ip, port); + std::string ip_port = pstd::IpPortString(ip, static_cast(port)); std::lock_guard l(slave_mutex_); auto iter = slaves_.begin(); @@ -723,7 +723,7 @@ bool PikaServer::TryAddSlave(const std::string& ip, int64_t port, int fd, SlaveItem s; s.ip_port = ip_port; s.ip = ip; - s.port = port; + s.port = static_cast(port); s.conn_fd = fd; s.stage = SLAVE_ITEM_STAGE_ONE; s.db_structs = db_structs; @@ -843,11 +843,11 @@ int PikaServer::GetMetaSyncTimestamp() { void PikaServer::UpdateMetaSyncTimestamp() { std::lock_guard sp_l(state_protector_); - last_meta_sync_timestamp_ = time(nullptr); + last_meta_sync_timestamp_ = static_cast(time(nullptr)); } void PikaServer::UpdateMetaSyncTimestampWithoutLock() { - last_meta_sync_timestamp_ = time(nullptr); + last_meta_sync_timestamp_ = static_cast(time(nullptr)); } bool PikaServer::IsFirstMetaSync() { @@ -1075,7 +1075,7 @@ int PikaServer::ClientKill(const std::string& ip_port) { int64_t PikaServer::ClientList(std::vector* clients) { int64_t clients_num = 0; - clients_num += pika_dispatch_thread_->ThreadClientList(clients); + clients_num += static_cast(pika_dispatch_thread_->ThreadClientList(clients)); return clients_num; } @@ -1167,7 +1167,7 @@ void PikaServer::SlowlogPushEntry(const PikaCmdArgsType& argv, int32_t time, int { std::lock_guard lock(slowlog_protector_); - entry.id = slowlog_entry_id_++; + entry.id = static_cast(slowlog_entry_id_++); entry.start_time = time; entry.duration = duration; slowlog_list_.push_front(entry); @@ -1289,7 +1289,7 @@ void PikaServer::AutoCompactRange() { gettimeofday(&now, nullptr); if (last_check_compact_time_.tv_sec == 0 || now.tv_sec - last_check_compact_time_.tv_sec >= interval * 3600) { gettimeofday(&last_check_compact_time_, nullptr); - if ((static_cast(free_size) / total_size) * 100 >= usage) { + if ((static_cast(free_size) / static_cast(total_size)) * 100 >= usage) { Status s = DoSameThingSpecificDB(TaskType::kCompactAll); if (s.ok()) { LOG(INFO) << "[Interval]schedule compactRange, freesize: " << free_size / 1048576 @@ -1310,7 +1310,7 @@ void PikaServer::AutoCompactRange() { bool have_week = false; std::string compact_cron; std::string week_str; - int slash_num = count(cc.begin(), cc.end(), '/'); + int64_t slash_num = count(cc.begin(), cc.end(), '/'); if (slash_num == 2) { have_week = true; std::string::size_type first_slash = cc.find('/'); @@ -1340,7 +1340,7 @@ void PikaServer::AutoCompactRange() { } if (!have_scheduled_crontask_ && in_window) { - if ((static_cast(free_size) / total_size) * 100 >= usage) { + if ((static_cast(free_size) / static_cast(total_size)) * 100 >= usage) { Status s = DoSameThingEverySlot(TaskType::kCompactAll); if (s.ok()) { LOG(INFO) << "[Cron]schedule compactRange, freesize: " << free_size / 1048576 @@ -1422,10 +1422,10 @@ void PikaServer::AutoDeleteExpiredDump() { now_time.tm_min = 0; now_time.tm_sec = 0; - long dump_timestamp = mktime(&dump_time); - long now_timestamp = mktime(&now_time); + int64_t dump_timestamp = mktime(&dump_time); + int64_t now_timestamp = mktime(&now_time); // How many days, 1 day = 86400s - int interval_days = (now_timestamp - dump_timestamp) / 86400; + int64_t interval_days = (now_timestamp - dump_timestamp) / 86400; if (interval_days >= expiry_days) { std::string dump_file = db_sync_path + i; @@ -1500,7 +1500,7 @@ void PikaServer::InitStorageOptions() { rocksdb::NewGenericRateLimiter( g_pika_conf->rate_limiter_bandwidth(), g_pika_conf->rate_limiter_refill_period_us(), - g_pika_conf->rate_limiter_fairness(), + static_cast(g_pika_conf->rate_limiter_fairness()), rocksdb::RateLimiter::Mode::kWritesOnly, g_pika_conf->rate_limiter_auto_tuned() )); @@ -1589,7 +1589,7 @@ void PikaServer::Bgslotsreload(const std::shared_ptr& slot) { bgslots_reload_.start_time = time(nullptr); char s_time[32]; - int len = strftime(s_time, sizeof(s_time), "%Y%m%d%H%M%S", localtime(&bgslots_reload_.start_time)); + size_t len = strftime(s_time, sizeof(s_time), "%Y%m%d%H%M%S", localtime(&bgslots_reload_.start_time)); bgslots_reload_.s_start_time.assign(s_time, len); bgslots_reload_.cursor = 0; bgslots_reload_.pattern = "*"; @@ -1658,7 +1658,7 @@ void PikaServer::Bgslotscleanup(std::vector cleanupSlots, const std::shared bgslots_cleanup_.start_time = time(nullptr); char s_time[32]; - int len = strftime(s_time, sizeof(s_time), "%Y%m%d%H%M%S", localtime(&bgslots_cleanup_.start_time)); + size_t len = strftime(s_time, sizeof(s_time), "%Y%m%d%H%M%S", localtime(&bgslots_cleanup_.start_time)); bgslots_cleanup_.s_start_time.assign(s_time, len); bgslots_cleanup_.cursor = 0; bgslots_cleanup_.pattern = "*"; diff --git a/src/pika_set.cc b/src/pika_set.cc index b982803c3e..2d6df4648e 100644 --- a/src/pika_set.cc +++ b/src/pika_set.cc @@ -58,9 +58,9 @@ void SPopCmd::Do(std::shared_ptr slot) { std::vector members; rocksdb::Status s = slot->db()->SPop(key_, &members, count_); if (s.ok()) { - res_.AppendArrayLen(members.size()); + res_.AppendArrayLenUint64(members.size()); for (const auto& member : members) { - res_.AppendStringLen(member.size()); + res_.AppendStringLenUint64(member.size()); res_.AppendContent(member); } } else if (s.IsNotFound()) { @@ -100,9 +100,9 @@ void SMembersCmd::Do(std::shared_ptr slot) { std::vector members; rocksdb::Status s = slot->db()->SMembers(key_, &members); if (s.ok() || s.IsNotFound()) { - res_.AppendArrayLen(members.size()); + res_.AppendArrayLenUint64(members.size()); for (const auto& member : members) { - res_.AppendStringLen(member.size()); + res_.AppendStringLenUint64(member.size()); res_.AppendContent(member); } } else { @@ -160,7 +160,7 @@ void SScanCmd::Do(std::shared_ptr slot) { res_.AppendStringLen(len); res_.AppendContent(buf); - res_.AppendArrayLen(members.size()); + res_.AppendArrayLenUint64(members.size()); for (const auto& member : members) { res_.AppendString(member); } @@ -198,9 +198,9 @@ void SUnionCmd::DoInitial() { void SUnionCmd::Do(std::shared_ptr slot) { std::vector members; slot->db()->SUnion(keys_, &members); - res_.AppendArrayLen(members.size()); + res_.AppendArrayLenUint64(members.size()); for (const auto& member : members) { - res_.AppendStringLen(member.size()); + res_.AppendStringLenUint64(member.size()); res_.AppendContent(member); } } @@ -278,9 +278,9 @@ void SInterCmd::DoInitial() { void SInterCmd::Do(std::shared_ptr slot) { std::vector members; slot->db()->SInter(keys_, &members); - res_.AppendArrayLen(members.size()); + res_.AppendArrayLenUint64(members.size()); for (const auto& member : members) { - res_.AppendStringLen(member.size()); + res_.AppendStringLenUint64(member.size()); res_.AppendContent(member); } } @@ -337,9 +337,9 @@ void SDiffCmd::DoInitial() { void SDiffCmd::Do(std::shared_ptr slot) { std::vector members; slot->db()->SDiff(keys_, &members); - res_.AppendArrayLen(members.size()); + res_.AppendArrayLenUint64(members.size()); for (const auto& member : members) { - res_.AppendStringLen(member.size()); + res_.AppendStringLenUint64(member.size()); res_.AppendContent(member); } } @@ -434,15 +434,15 @@ void SRandmemberCmd::DoInitial() { void SRandmemberCmd::Do(std::shared_ptr slot) { std::vector members; - rocksdb::Status s = slot->db()->SRandmember(key_, count_, &members); + rocksdb::Status s = slot->db()->SRandmember(key_, static_cast(count_), &members); if (s.ok() || s.IsNotFound()) { if (!reply_arr && (static_cast(!members.empty()) != 0U)) { - res_.AppendStringLen(members[0].size()); + res_.AppendStringLenUint64(members[0].size()); res_.AppendContent(members[0]); } else { - res_.AppendArrayLen(members.size()); + res_.AppendArrayLenUint64(members.size()); for (const auto& member : members) { - res_.AppendStringLen(member.size()); + res_.AppendStringLenUint64(member.size()); res_.AppendContent(member); } } diff --git a/src/pika_slave_node.cc b/src/pika_slave_node.cc index 2d4d218422..b3faa6f067 100644 --- a/src/pika_slave_node.cc +++ b/src/pika_slave_node.cc @@ -54,7 +54,7 @@ bool SyncWindow::Update(const SyncWinItem& start_item, const SyncWinItem& end_it int SyncWindow::Remaining() { std::size_t remaining_size = g_pika_conf->sync_window_size() - win_.size(); - return remaining_size > 0 ? remaining_size : 0; + return static_cast(remaining_size > 0 ? remaining_size : 0); } /* SlaveNode */ diff --git a/src/pika_slot.cc b/src/pika_slot.cc index 1970b1c542..3d9671bf8d 100644 --- a/src/pika_slot.cc +++ b/src/pika_slot.cc @@ -355,7 +355,7 @@ bool Slot::InitBgsaveEnv() { // Prepare for bgsave dir bgsave_info_.start_time = time(nullptr); char s_time[32]; - int len = strftime(s_time, sizeof(s_time), "%Y%m%d%H%M%S", localtime(&bgsave_info_.start_time)); + int len = static_cast(strftime(s_time, sizeof(s_time), "%Y%m%d%H%M%S", localtime(&bgsave_info_.start_time))); bgsave_info_.s_start_time.assign(s_time, len); std::string time_sub_path = g_pika_conf->bgsave_prefix() + std::string(s_time, 8); bgsave_info_.path = g_pika_conf->bgsave_path() + time_sub_path + "/" + bgsave_sub_path_; @@ -477,7 +477,7 @@ bool Slot::FlushSubDB(const std::string& db_name) { void Slot::InitKeyScan() { key_scan_info_.start_time = time(nullptr); char s_time[32]; - int len = strftime(s_time, sizeof(s_time), "%Y-%m-%d %H:%M:%S", localtime(&key_scan_info_.start_time)); + int len = static_cast(strftime(s_time, sizeof(s_time), "%Y-%m-%d %H:%M:%S", localtime(&key_scan_info_.start_time))); key_scan_info_.s_start_time.assign(s_time, len); key_scan_info_.duration = -1; // duration -1 mean the task in processing } @@ -503,7 +503,7 @@ Status Slot::GetKeyNum(std::vector* key_info) { return Status::Corruption(s.ToString()); } key_scan_info_.key_infos = *key_info; - key_scan_info_.duration = time(nullptr) - key_scan_info_.start_time; + key_scan_info_.duration = static_cast(time(nullptr) - key_scan_info_.start_time); return Status::OK(); } diff --git a/src/pika_slot_command.cc b/src/pika_slot_command.cc index 954826e0bd..d3f5b26e30 100644 --- a/src/pika_slot_command.cc +++ b/src/pika_slot_command.cc @@ -750,7 +750,7 @@ static int SlotsMgrtTag(const std::string &host, const int port, int timeout, co // get slot tag static const char *GetSlotsTag(const std::string &str, int *plen) { const char *s = str.data(); - int i, j, n = str.length(); + int i, j, n = static_cast(str.length()); for (i = 0; i < n && s[i] != '{'; i++) { } if (i == n) { @@ -782,11 +782,11 @@ int GetSlotsID(const std::string &str, uint32_t *pcrc, int *phastag) { int hastag = 0; const char *tag = GetSlotsTag(str, &taglen); if (tag == nullptr) { - tag = s, taglen = str.length(); + tag = s, taglen = static_cast(str.length()); } else { hastag = 1; } - uint32_t crc = CRC32CheckSum(tag, taglen); + auto crc = static_cast(CRC32CheckSum(tag, taglen)); if (pcrc != nullptr) { *pcrc = crc; } @@ -979,7 +979,7 @@ void SlotsMgrtTagSlotCmd::Do(std::shared_ptr slot) { int32_t len = 0; int ret = 0; std::string detail; - std::string slot_key = GetSlotKey(slot_id_); + std::string slot_key = GetSlotKey(static_cast(slot_id_)); // first, get the count of slot_key, prevent to sscan key very slowly when the key is not found rocksdb::Status s = slot->db()->SCard(slot_key, &len); @@ -998,7 +998,7 @@ void SlotsMgrtTagSlotCmd::Do(std::shared_ptr slot) { std::string key = member; char type = key.at(0); key.erase(key.begin()); - ret = SlotsMgrtTag(dest_ip_, dest_port_, timeout_ms_, key, type, detail, slot); + ret = SlotsMgrtTag(dest_ip_, static_cast(dest_port_), static_cast(timeout_ms_), key, type, detail, slot); } } // unlock @@ -1174,11 +1174,11 @@ void SlotsMgrtTagOneCmd::Do(std::shared_ptr slot) { detail = "cont get the key type."; ret = -1; } else { - ret = SlotsMgrtTag(dest_ip_, dest_port_, timeout_ms_, key_, key_type_, detail, slot); + ret = SlotsMgrtTag(dest_ip_, static_cast(dest_port_), static_cast(timeout_ms_), key_, key_type_, detail, slot); } } else { // key maybe doesn't exist, the key is tag key, migrate the same tag key - ret = SlotsMgrtTag(dest_ip_, dest_port_, timeout_ms_, key_, 0, detail, slot); + ret = SlotsMgrtTag(dest_ip_, static_cast(dest_port_), static_cast(timeout_ms_), key_, 0, detail, slot); } // unlock the record lock @@ -1252,7 +1252,7 @@ void SlotsInfoCmd::Do(std::shared_ptr slot) { int32_t len = 0; std::string slot_key; - for (int i = begin_; i < end_; i++) { + for (auto i = static_cast(begin_); i < end_; i++) { slot_key = GetSlotKey(i); len = 0; rocksdb::Status s = slot->db()->SCard(slot_key, &len); @@ -1336,7 +1336,7 @@ void SlotsMgrtTagSlotAsyncCmd::Do(std::shared_ptr slot) { } int32_t remained = 0; - std::string slotKey = GetSlotKey(slot_id_); + std::string slotKey = GetSlotKey(static_cast(slot_id_)); storage::Status status = slot->db()->SCard(slotKey, &remained); if (status.IsNotFound()) { LOG(INFO) << "find no record in slot " << slot_id_; @@ -1380,19 +1380,19 @@ void SlotsMgrtAsyncStatusCmd::Do(std::shared_ptr slot) { std::string mstatus = migrating ? "yes" : "no"; res_.AppendArrayLen(5); status = "dest server: " + ip + ":" + std::to_string(port); - res_.AppendStringLen(status.size()); + res_.AppendStringLenUint64(status.size()); res_.AppendContent(status); status = "slot number: " + std::to_string(slots); - res_.AppendStringLen(status.size()); + res_.AppendStringLenUint64(status.size()); res_.AppendContent(status); status = "migrating : " + mstatus; - res_.AppendStringLen(status.size()); + res_.AppendStringLenUint64(status.size()); res_.AppendContent(status); status = "moved keys : " + std::to_string(moved); - res_.AppendStringLen(status.size()); + res_.AppendStringLenUint64(status.size()); res_.AppendContent(status); status = "remain keys: " + std::to_string(remained); - res_.AppendStringLen(status.size()); + res_.AppendStringLenUint64(status.size()); res_.AppendContent(status); return; @@ -1455,7 +1455,7 @@ void SlotsHashKeyCmd::DoInitial() { void SlotsHashKeyCmd::Do(std::shared_ptr slot) { std::vector::const_iterator keys_it; - res_.AppendArrayLen(keys_.size()); + res_.AppendArrayLenUint64(keys_.size()); for (keys_it = keys_.begin(); keys_it != keys_.end(); ++keys_it) { res_.AppendInteger(GetSlotsID(*keys_it, nullptr, nullptr)); } @@ -1519,10 +1519,10 @@ void SlotsScanCmd::Do(std::shared_ptr slot) { res_.AppendStringLen(len); res_.AppendContent(buf); - res_.AppendArrayLen(members.size()); + res_.AppendArrayLenUint64(members.size()); auto iter_member = members.begin(); for (; iter_member != members.end(); iter_member++) { - res_.AppendStringLen(iter_member->size()); + res_.AppendStringLenUint64(iter_member->size()); res_.AppendContent(*iter_member); } return; @@ -1615,7 +1615,7 @@ void SlotsCleanupCmd::DoInitial() { void SlotsCleanupCmd::Do(std::shared_ptr slot) { g_pika_server->Bgslotscleanup(cleanup_slots_, slot); std::vector cleanup_slots(g_pika_server->GetCleanupSlots()); - res_.AppendArrayLen(cleanup_slots.size()); + res_.AppendArrayLenUint64(cleanup_slots.size()); auto iter = cleanup_slots.begin(); for (; iter != cleanup_slots.end(); iter++) { res_.AppendInteger(*iter); diff --git a/src/pika_stable_log.cc b/src/pika_stable_log.cc index 25a270d787..aae650263b 100644 --- a/src/pika_stable_log.cc +++ b/src/pika_stable_log.cc @@ -89,7 +89,7 @@ bool StableLog::PurgeFiles(uint32_t to, bool manual) { int delete_num = 0; struct stat file_stat; - int remain_expire_num = binlogs.size() - g_pika_conf->expire_logs_nums(); + auto remain_expire_num = static_cast(binlogs.size() - g_pika_conf->expire_logs_nums()); std::shared_ptr master_slot = nullptr; std::map::iterator it; for (it = binlogs.begin(); it != binlogs.end(); ++it) { diff --git a/src/pika_zset.cc b/src/pika_zset.cc index 22440fb125..6d26552113 100644 --- a/src/pika_zset.cc +++ b/src/pika_zset.cc @@ -111,7 +111,7 @@ void ZScanCmd::Do(std::shared_ptr slot) { res_.AppendStringLen(len); res_.AppendContent(buf); - res_.AppendArrayLen(score_members.size() * 2); + res_.AppendArrayLenUint64(score_members.size() * 2); for (const auto& score_member : score_members) { res_.AppendString(score_member.member); @@ -179,23 +179,23 @@ void ZRangeCmd::DoInitial() { void ZRangeCmd::Do(std::shared_ptr slot) { std::vector score_members; - rocksdb::Status s = slot->db()->ZRange(key_, start_, stop_, &score_members); + rocksdb::Status s = slot->db()->ZRange(key_, static_cast(start_), static_cast(stop_), &score_members); if (s.ok() || s.IsNotFound()) { if (is_ws_) { char buf[32]; int64_t len; - res_.AppendArrayLen(score_members.size() * 2); + res_.AppendArrayLenUint64(score_members.size() * 2); for (const auto& sm : score_members) { - res_.AppendStringLen(sm.member.size()); + res_.AppendStringLenUint64(sm.member.size()); res_.AppendContent(sm.member); len = pstd::d2string(buf, sizeof(buf), sm.score); res_.AppendStringLen(len); res_.AppendContent(buf); } } else { - res_.AppendArrayLen(score_members.size()); + res_.AppendArrayLenUint64(score_members.size()); for (const auto& sm : score_members) { - res_.AppendStringLen(sm.member.size()); + res_.AppendStringLenUint64(sm.member.size()); res_.AppendContent(sm.member); } } @@ -214,23 +214,23 @@ void ZRevrangeCmd::DoInitial() { void ZRevrangeCmd::Do(std::shared_ptr slot) { std::vector score_members; - rocksdb::Status s = slot->db()->ZRevrange(key_, start_, stop_, &score_members); + rocksdb::Status s = slot->db()->ZRevrange(key_, static_cast(start_), static_cast(stop_), &score_members); if (s.ok() || s.IsNotFound()) { if (is_ws_) { char buf[32]; int64_t len; - res_.AppendArrayLen(score_members.size() * 2); + res_.AppendArrayLenUint64(score_members.size() * 2); for (const auto& sm : score_members) { - res_.AppendStringLen(sm.member.size()); + res_.AppendStringLenUint64(sm.member.size()); res_.AppendContent(sm.member); len = pstd::d2string(buf, sizeof(buf), sm.score); res_.AppendStringLen(len); res_.AppendContent(buf); } } else { - res_.AppendArrayLen(score_members.size()); + res_.AppendArrayLenUint64(score_members.size()); for (const auto& sm : score_members) { - res_.AppendStringLen(sm.member.size()); + res_.AppendStringLenUint64(sm.member.size()); res_.AppendContent(sm.member); } } @@ -331,7 +331,7 @@ void ZRangebyscoreCmd::Do(std::shared_ptr slot) { res_.SetRes(CmdRes::kErrOther, s.ToString()); return; } - FitLimit(count_, offset_, score_members.size()); + FitLimit(count_, offset_, static_cast(score_members.size())); size_t index = offset_; size_t end = offset_ + count_; if (with_scores_) { @@ -339,7 +339,7 @@ void ZRangebyscoreCmd::Do(std::shared_ptr slot) { int64_t len; res_.AppendArrayLen(count_ * 2); for (; index < end; index++) { - res_.AppendStringLen(score_members[index].member.size()); + res_.AppendStringLenUint64(score_members[index].member.size()); res_.AppendContent(score_members[index].member); len = pstd::d2string(buf, sizeof(buf), score_members[index].score); res_.AppendStringLen(len); @@ -348,7 +348,7 @@ void ZRangebyscoreCmd::Do(std::shared_ptr slot) { } else { res_.AppendArrayLen(count_); for (; index < end; index++) { - res_.AppendStringLen(score_members[index].member.size()); + res_.AppendStringLenUint64(score_members[index].member.size()); res_.AppendContent(score_members[index].member); } } @@ -383,7 +383,7 @@ void ZRevrangebyscoreCmd::Do(std::shared_ptr slot) { res_.SetRes(CmdRes::kErrOther, s.ToString()); return; } - FitLimit(count_, offset_, score_members.size()); + FitLimit(count_, offset_, static_cast(score_members.size())); int64_t index = offset_; int64_t end = offset_ + count_; if (with_scores_) { @@ -391,7 +391,7 @@ void ZRevrangebyscoreCmd::Do(std::shared_ptr slot) { int64_t len; res_.AppendArrayLen(count_ * 2); for (; index < end; index++) { - res_.AppendStringLen(score_members[index].member.size()); + res_.AppendStringLenUint64(score_members[index].member.size()); res_.AppendContent(score_members[index].member); len = pstd::d2string(buf, sizeof(buf), score_members[index].score); res_.AppendStringLen(len); @@ -400,7 +400,7 @@ void ZRevrangebyscoreCmd::Do(std::shared_ptr slot) { } else { res_.AppendArrayLen(count_); for (; index < end; index++) { - res_.AppendStringLen(score_members[index].member.size()); + res_.AppendStringLenUint64(score_members[index].member.size()); res_.AppendContent(score_members[index].member); } } @@ -465,14 +465,14 @@ void ZsetUIstoreParentCmd::DoInitial() { res_.SetRes(CmdRes::kErrOther, "at least 1 input key is needed for ZUNIONSTORE/ZINTERSTORE"); return; } - int argc = argv_.size(); + auto argc = argv_.size(); if (argc < num_keys_ + 3) { res_.SetRes(CmdRes::kSyntaxErr); return; } keys_.assign(argv_.begin() + 3, argv_.begin() + 3 + num_keys_); weights_.assign(num_keys_, 1); - int index = num_keys_ + 3; + auto index = num_keys_ + 3; while (index < argc) { if (strcasecmp(argv_[index].data(), "weights") == 0) { index++; @@ -481,7 +481,7 @@ void ZsetUIstoreParentCmd::DoInitial() { return; } double weight; - int base = index; + auto base = index; for (; index < base + num_keys_; index++) { if (pstd::string2d(argv_[index].data(), argv_[index].size(), &weight) == 0) { res_.SetRes(CmdRes::kErrOther, "weight value is not a float"); @@ -788,13 +788,13 @@ void ZRangebylexCmd::Do(std::shared_ptr slot) { res_.SetRes(CmdRes::kErrOther, s.ToString()); return; } - FitLimit(count_, offset_, members.size()); + FitLimit(count_, offset_, static_cast(members.size())); res_.AppendArrayLen(count_); size_t index = offset_; size_t end = offset_ + count_; for (; index < end; index++) { - res_.AppendStringLen(members[index].size()); + res_.AppendStringLenUint64(members[index].size()); res_.AppendContent(members[index]); } } @@ -828,13 +828,13 @@ void ZRevrangebylexCmd::Do(std::shared_ptr slot) { res_.SetRes(CmdRes::kErrOther, s.ToString()); return; } - FitLimit(count_, offset_, members.size()); + FitLimit(count_, offset_, static_cast(members.size())); res_.AppendArrayLen(count_); - int64_t index = members.size() - 1 - offset_; + int64_t index = static_cast(members.size()) - 1 - offset_; int64_t end = index - count_; for (; index > end; index--) { - res_.AppendStringLen(members[index].size()); + res_.AppendStringLenUint64(members[index].size()); res_.AppendContent(members[index]); } } @@ -884,7 +884,7 @@ void ZRemrangebyrankCmd::DoInitial() { void ZRemrangebyrankCmd::Do(std::shared_ptr slot) { int32_t count = 0; - rocksdb::Status s = slot->db()->ZRemrangebyrank(key_, start_rank_, stop_rank_, &count); + rocksdb::Status s = slot->db()->ZRemrangebyrank(key_, static_cast(start_rank_), static_cast(stop_rank_), &count); if (s.ok() || s.IsNotFound()) { res_.AppendInteger(count); } else { @@ -970,7 +970,7 @@ void ZPopmaxCmd::Do(std::shared_ptr slot) { if (s.ok() || s.IsNotFound()) { char buf[32]; int64_t len; - res_.AppendArrayLen(score_members.size() * 2); + res_.AppendArrayLenUint64(score_members.size() * 2); for (const auto& sm : score_members) { res_.AppendString(sm.member); len = pstd::d2string(buf, sizeof(buf), sm.score); @@ -1004,7 +1004,7 @@ void ZPopminCmd::Do(std::shared_ptr slot) { if (s.ok() || s.IsNotFound()) { char buf[32]; int64_t len; - res_.AppendArrayLen(score_members.size() * 2); + res_.AppendArrayLenUint64(score_members.size() * 2); for (const auto& sm : score_members) { res_.AppendString(sm.member); len = pstd::d2string(buf, sizeof(buf), sm.score); diff --git a/src/pstd/include/pstd_status.h b/src/pstd/include/pstd_status.h index a3f1dc189e..38bb9459c7 100644 --- a/src/pstd/include/pstd_status.h +++ b/src/pstd/include/pstd_status.h @@ -112,7 +112,7 @@ inline Status::Status(const Status& s) { state_ = !s.state_ ? nullptr : CopyStat inline void Status::operator=(const Status& s) { // The following condition catches both aliasing (when this == &s), // and the common case where both s and *this are ok. - if (state_ != s.state_) { + if (&s != this && state_ != s.state_) { delete[] state_; state_ = !s.state_ ? nullptr : CopyState(s.state_); } diff --git a/src/pstd/src/base_conf.cc b/src/pstd/src/base_conf.cc index 14f01c4080..c12b8dc81e 100644 --- a/src/pstd/src/base_conf.cc +++ b/src/pstd/src/base_conf.cc @@ -45,7 +45,7 @@ int BaseConf::LoadConf() { name_len = 0; value_len = 0; type = Rep::kComment; - line_len = strlen(line); + line_len = static_cast(strlen(line)); for (int i = 0; i < line_len; i++) { if (i == 0 && line[i] == COMMENT) { type = Rep::kComment; @@ -112,7 +112,7 @@ bool BaseConf::GetConfIntHuman(const std::string& name, int* value) const { } if (name == i.name) { auto c_str = i.value.c_str(); - (*value) = strtoll(c_str, nullptr, 10); + (*value) = static_cast(strtoll(c_str, nullptr, 10)); char last = c_str[i.value.size() - 1]; if (last == 'K' || last == 'k') { (*value) *= (1 << 10); diff --git a/src/pstd/src/env.cc b/src/pstd/src/env.cc index 149fe5a0b6..0de2c77a7a 100644 --- a/src/pstd/src/env.cc +++ b/src/pstd/src/env.cc @@ -255,7 +255,7 @@ class PosixSequentialFile : public SequentialFile { } Status Skip(uint64_t n) override { - if (fseek(file_, n, SEEK_CUR) != 0) { + if (fseek(file_, static_cast(n), SEEK_CUR) != 0) { return IOError(filename_, errno); } return Status::OK(); @@ -333,12 +333,12 @@ class PosixMmapFile : public WritableFile { #if defined(__APPLE__) if (ftruncate(fd_, file_offset_ + map_size_) != 0) { #else - if (posix_fallocate(fd_, file_offset_, map_size_) != 0) { + if (posix_fallocate(fd_, static_cast(file_offset_), static_cast(map_size_)) != 0) { #endif LOG(WARNING) << "ftruncate error"; return false; } - void* ptr = mmap(nullptr, map_size_, PROT_READ | PROT_WRITE, MAP_SHARED, fd_, file_offset_); + void* ptr = mmap(nullptr, map_size_, PROT_READ | PROT_WRITE, MAP_SHARED, fd_, static_cast(file_offset_)); if (ptr == MAP_FAILED) { // NOLINT LOG(WARNING) << "mmap failed"; return false; @@ -402,7 +402,7 @@ class PosixMmapFile : public WritableFile { s = IOError(filename_, errno); } else if (unused > 0) { // Trim the extra space at the end of the file - if (ftruncate(fd_, file_offset_ - unused) < 0) { + if (ftruncate(fd_, static_cast(file_offset_ - unused)) < 0) { s = IOError(filename_, errno); } } @@ -485,7 +485,7 @@ class MmapRWFile : public RWFile { #if defined(__APPLE__) if (ftruncate(fd_, map_size_) != 0) { #else - if (posix_fallocate(fd_, 0, map_size_) != 0) { + if (posix_fallocate(fd_, 0, static_cast(map_size_)) != 0) { #endif return false; } @@ -539,7 +539,7 @@ class PosixRandomRWFile : public RandomRWFile { pending_fsync_ = true; while (left != 0) { - ssize_t done = pwrite(fd_, src, left, offset); + ssize_t done = pwrite(fd_, src, left, static_cast(offset)); if (done < 0) { if (errno == EINTR) { continue; diff --git a/src/pstd/src/posix.cc b/src/pstd/src/posix.cc index a435e4ea34..53957d99cc 100644 --- a/src/pstd/src/posix.cc +++ b/src/pstd/src/posix.cc @@ -482,7 +482,7 @@ ssize_t rio_readn(int fd, void* usrbuf, size_t n) { nleft -= nread; bufp += nread; } - return (n - nleft); /* return >= 0 */ + return static_cast(n - nleft); /* return >= 0 */ } /* $end rio_readn */ @@ -506,7 +506,7 @@ ssize_t rio_writen(int fd, void* usrbuf, size_t n) { nleft -= nwritten; bufp += nwritten; } - return n; + return static_cast(n); } /* $end rio_writen */ @@ -523,7 +523,7 @@ static ssize_t rio_read(rio_t* rp, char* usrbuf, size_t n) { int cnt; while (rp->rio_cnt <= 0) { /* refill if buf is empty */ - rp->rio_cnt = read(rp->rio_fd, rp->rio_buf, sizeof(rp->rio_buf)); + rp->rio_cnt = static_cast(read(rp->rio_fd, rp->rio_buf, sizeof(rp->rio_buf))); if (rp->rio_cnt < 0) { if (errno != EINTR) { /* interrupted by sig handler return */ return -1; @@ -536,7 +536,7 @@ static ssize_t rio_read(rio_t* rp, char* usrbuf, size_t n) { } /* Copy min(n, rp->rio_cnt) bytes from internal buf to user buf */ - cnt = n; + cnt = static_cast(n); if (rp->rio_cnt < static_cast(n)) { cnt = rp->rio_cnt; } @@ -580,7 +580,7 @@ ssize_t rio_readnb(rio_t* rp, void* usrbuf, size_t n) { nleft -= nread; bufp += nread; } - return (n - nleft); /* return >= 0 */ + return static_cast(n - nleft); /* return >= 0 */ } /* $end rio_readnb */ @@ -595,7 +595,7 @@ ssize_t rio_readlineb(rio_t* rp, void* usrbuf, size_t maxlen) { char *bufp = static_cast(usrbuf); for (n = 1; n < maxlen; n++) { - if ((rc = rio_read(rp, &c, 1)) == 1) { + if ((rc = static_cast(rio_read(rp, &c, 1))) == 1) { *bufp++ = c; if (c == '\n') { break; } @@ -610,7 +610,7 @@ ssize_t rio_readlineb(rio_t* rp, void* usrbuf, size_t maxlen) { } } *bufp = 0; - return n; + return static_cast(n); } /* $end rio_readlineb */ diff --git a/src/pstd/src/pstd_hash.cc b/src/pstd/src/pstd_hash.cc index 120da79c01..eaed3e90fe 100644 --- a/src/pstd/src/pstd_hash.cc +++ b/src/pstd/src/pstd_hash.cc @@ -288,7 +288,7 @@ std::string sha256(const std::string& input, bool raw) { if (raw) { std::string res; for (unsigned char i : digest) { - res.append(1, i); + res.append(1, static_cast(i)); } return res; } @@ -337,19 +337,19 @@ inline MD5::uint4 MD5::rotate_left(uint4 x, int n) { return (x << n) | (x >> (32 // FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. // Rotation is separate from addition to prevent recomputation. inline void MD5::FF(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) { - a = rotate_left(a + F(b, c, d) + x + ac, s) + b; + a = rotate_left(a + F(b, c, d) + x + ac, static_cast(s)) + b; } inline void MD5::GG(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) { - a = rotate_left(a + G(b, c, d) + x + ac, s) + b; + a = rotate_left(a + G(b, c, d) + x + ac, static_cast(s)) + b; } inline void MD5::HH(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) { - a = rotate_left(a + H(b, c, d) + x + ac, s) + b; + a = rotate_left(a + H(b, c, d) + x + ac, static_cast(s)) + b; } inline void MD5::II(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) { - a = rotate_left(a + I(b, c, d) + x + ac, s) + b; + a = rotate_left(a + I(b, c, d) + x + ac, static_cast(s)) + b; } ////////////////////////////////////////////// @@ -600,7 +600,7 @@ std::string MD5::rawdigest() const { } std::string res; for (unsigned char i : digest) { - res.append(1, i); + res.append(1, static_cast(i)); } return res; } diff --git a/src/pstd/src/pstd_string.cc b/src/pstd/src/pstd_string.cc index fe48e76cbd..fda381583c 100644 --- a/src/pstd/src/pstd_string.cc +++ b/src/pstd/src/pstd_string.cc @@ -184,7 +184,8 @@ int stringmatchlen(const char* pattern, int patternLen, const char* string, int } int stringmatch(const char* pattern, const char* string, int nocase) { - return stringmatchlen(pattern, strlen(pattern), string, strlen(string), nocase); + return stringmatchlen(pattern, static_cast(strlen(pattern)), + string, static_cast(strlen(string)), nocase); } /* Convert a string representing an amount of memory into the number of @@ -320,7 +321,7 @@ int ll2string(char* dst, size_t dstlen, long long svalue) { dst[next] = '\0'; next--; while (value >= 100) { - int const i = (value % 100) * 2; + int const i = static_cast((value % 100) * 2); value /= 100; dst[next] = digits[i + 1]; dst[next - 1] = digits[i]; @@ -329,9 +330,9 @@ int ll2string(char* dst, size_t dstlen, long long svalue) { /* Handle last 1-2 digits. */ if (value < 10) { - dst[next] = '0' + static_cast(value); + dst[next] = static_cast('0' + value); } else { - int i = static_cast(value) * 2; + auto i = static_cast(value) * 2; dst[next] = digits[i + 1]; dst[next - 1] = digits[i]; } @@ -340,7 +341,7 @@ int ll2string(char* dst, size_t dstlen, long long svalue) { if (negative != 0) { dst[0] = '-'; } - return length; + return static_cast(length); } /* Convert a string into a long long. Returns 1 if the string could be parsed @@ -424,14 +425,14 @@ int string2int(const char* s, size_t slen, long long* value) { return 0; } if (value) { - *value = -v; + *value = static_cast(-v); } } else { if (v > LLONG_MAX) { /* Overflow. */ return 0; } if (value) { - *value = v; + *value = static_cast(v); } } return 1; @@ -511,7 +512,7 @@ int d2string(char* buf, size_t len, double value) { len = snprintf(buf, len, "%.17g", value); } - return len; + return static_cast(len); } int string2d(const char* s, size_t slen, double* dval) { @@ -574,7 +575,7 @@ std::string getRandomHexChars(const size_t len) { /* Finally xor it with rand() output, that was already seeded with * time() at startup. */ for (j = 0; j < len; j++) { - p[j] ^= rand(); + p[j] = static_cast(p[j] ^ rand()); } } /* Turn it into hex digits taking just 4 bits out of 8 for every byte. */ @@ -701,7 +702,7 @@ std::string StringTrim(const std::string& ori, const std::string& charlist) { } size_t pos = 0; - int rpos = ori.size() - 1; + size_t rpos = ori.size() - 1; while (pos < ori.size()) { bool meet = false; for (char c : charlist) { diff --git a/src/storage/include/storage/util.h b/src/storage/include/storage/util.h index 855ca2a2b8..0849321d64 100644 --- a/src/storage/include/storage/util.h +++ b/src/storage/include/storage/util.h @@ -18,6 +18,7 @@ namespace storage { int Int64ToStr(char* dst, size_t dstlen, int64_t svalue); int StrToInt64(const char* s, size_t slen, int64_t* value); int StringMatch(const char* pattern, int pattern_len, const char* string, int string_len, int nocase); +int StringMatch(const char* pattern, uint64_t pattern_len, const char* string, uint64_t string_len, int nocase); int StrToLongDouble(const char* s, size_t slen, long double* ldval); int LongDoubleToStr(long double ldval, std::string* value); int do_mkdir(const char* path, mode_t mode); diff --git a/src/storage/src/redis_hashes.cc b/src/storage/src/redis_hashes.cc index 2fbeb9a2c9..510e74e06d 100644 --- a/src/storage/src/redis_hashes.cc +++ b/src/storage/src/redis_hashes.cc @@ -168,7 +168,7 @@ Status RedisHashes::PKPatternMatchDel(const std::string& pattern, int32_t* ret) if (static_cast(batch.Count()) >= BATCH_DELETE_LIMIT) { s = db_->Write(default_write_options_, &batch); if (s.ok()) { - total_delete += batch.Count(); + total_delete += static_cast( batch.Count()); batch.Clear(); } else { *ret = total_delete; @@ -180,7 +180,7 @@ Status RedisHashes::PKPatternMatchDel(const std::string& pattern, int32_t* ret) if (batch.Count() != 0U) { s = db_->Write(default_write_options_, &batch); if (s.ok()) { - total_delete += batch.Count(); + total_delete += static_cast(batch.Count()); batch.Clear(); } } @@ -563,7 +563,7 @@ Status RedisHashes::HMSet(const Slice& key, const std::vector& fvs) ParsedHashesMetaValue parsed_hashes_meta_value(&meta_value); if (parsed_hashes_meta_value.IsStale() || parsed_hashes_meta_value.count() == 0) { version = parsed_hashes_meta_value.InitialMetaValue(); - parsed_hashes_meta_value.set_count(filtered_fvs.size()); + parsed_hashes_meta_value.set_count(static_cast(filtered_fvs.size())); batch.Put(handles_[0], key, meta_value); for (const auto& fv : filtered_fvs) { HashesDataKey hashes_data_key(key, version, fv.field); @@ -741,7 +741,7 @@ Status RedisHashes::HStrlen(const Slice& key, const Slice& field, int32_t* len) std::string value; Status s = HGet(key, field, &value); if (s.ok()) { - *len = value.size(); + *len = static_cast(value.size()); } else { *len = 0; } @@ -1285,7 +1285,7 @@ void RedisHashes::ScanDatabase() { ScopeSnapshot ss(db_, &snapshot); iterator_options.snapshot = snapshot; iterator_options.fill_cache = false; - int32_t current_time = time(nullptr); + auto current_time = static_cast(time(nullptr)); LOG(INFO) << "***************Hashes Meta Data***************"; auto meta_iter = db_->NewIterator(iterator_options, handles_[0]); diff --git a/src/storage/src/redis_hyperloglog.cc b/src/storage/src/redis_hyperloglog.cc index 1372f37aaa..52dae42465 100644 --- a/src/storage/src/redis_hyperloglog.cc +++ b/src/storage/src/redis_hyperloglog.cc @@ -32,10 +32,10 @@ HyperLogLog::~HyperLogLog() = default; std::string HyperLogLog::Add(const char* value, uint32_t len) { uint32_t hash_value; - MurmurHash3_x86_32(value, len, HLL_HASH_SEED, static_cast(&hash_value)); - int32_t index = hash_value & ((1 << b_) - 1); - uint8_t rank = Nctz((hash_value >> b_), 32 - b_); - if (rank > register_[index]) { register_[index] = rank; + MurmurHash3_x86_32(value, static_cast(len), HLL_HASH_SEED, static_cast(&hash_value)); + uint32_t index = hash_value & ((1 << b_) - 1); + uint8_t rank = Nctz((hash_value >> b_), static_cast(32 - b_)); + if (rank > register_[index]) { register_[index] = static_cast(rank); } std::string result(m_, 0); for (uint32_t i = 0; i < m_; ++i) { @@ -97,7 +97,7 @@ std::string HyperLogLog::Merge(const HyperLogLog& hll) { } for (uint32_t r = 0; r < m_; r++) { if (register_[r] < hll.register_[r]) { - register_[r] |= hll.register_[r]; + register_[r] = static_cast(register_[r] | hll.register_[r]); } } diff --git a/src/storage/src/redis_lists.cc b/src/storage/src/redis_lists.cc index 135ac8b5f3..3e8a71433a 100644 --- a/src/storage/src/redis_lists.cc +++ b/src/storage/src/redis_lists.cc @@ -175,7 +175,7 @@ Status RedisLists::PKPatternMatchDel(const std::string& pattern, int32_t* ret) { if (static_cast(batch.Count()) >= BATCH_DELETE_LIMIT) { s = db_->Write(default_write_options_, &batch); if (s.ok()) { - total_delete += batch.Count(); + total_delete += static_cast(batch.Count()); batch.Clear(); } else { *ret = total_delete; @@ -187,7 +187,7 @@ Status RedisLists::PKPatternMatchDel(const std::string& pattern, int32_t* ret) { if (batch.Count() != 0U) { s = db_->Write(default_write_options_, &batch); if (s.ok()) { - total_delete += batch.Count(); + total_delete += static_cast(batch.Count()); batch.Clear(); } } @@ -245,7 +245,7 @@ Status RedisLists::LInsert(const Slice& key, const BeforeOrAfter& before_or_afte } else { bool find_pivot = false; uint64_t pivot_index = 0; - uint32_t version = parsed_lists_meta_value.version(); + int32_t version = parsed_lists_meta_value.version(); uint64_t current_index = parsed_lists_meta_value.left_index() + 1; rocksdb::Iterator* iter = db_->NewIterator(default_read_options_, handles_[1]); ListsDataKey start_data_key(key, version, current_index); @@ -315,7 +315,7 @@ Status RedisLists::LInsert(const Slice& key, const BeforeOrAfter& before_or_afte batch.Put(handles_[0], key, meta_value); ListsDataKey lists_target_key(key, version, target_index); batch.Put(handles_[1], lists_target_key.Encode(), value); - *ret = parsed_lists_meta_value.count(); + *ret = static_cast(parsed_lists_meta_value.count()); return db_->Write(default_write_options_, &batch); } } @@ -359,10 +359,10 @@ Status RedisLists::LPop(const Slice& key, int64_t count, std::vector(parsed_lists_meta_value.count()); int32_t version = parsed_lists_meta_value.version(); int32_t start_index = 0; - int32_t stop_index = count<=size?count-1:size-1; + auto stop_index = static_cast(count<=size?count-1:size-1); int32_t cur_index = 0; ListsDataKey lists_data_key(key, version, parsed_lists_meta_value.left_index()+1); rocksdb::Iterator* iter = db_->NewIterator(default_read_options_, handles_[1]); @@ -527,7 +527,7 @@ Status RedisLists::LRem(const Slice& key, int64_t count, const Slice& value, uin std::vector target_index; std::vector delete_index; uint64_t rest = (count < 0) ? -count : count; - uint32_t version = parsed_lists_meta_value.version(); + int32_t version = parsed_lists_meta_value.version(); uint64_t start_index = parsed_lists_meta_value.left_index() + 1; uint64_t stop_index = parsed_lists_meta_value.right_index() - 1; ListsDataKey start_data_key(key, version, start_index); @@ -639,7 +639,7 @@ Status RedisLists::LSet(const Slice& key, int64_t index, const Slice& value) { } else if (parsed_lists_meta_value.count() == 0) { return Status::NotFound(); } else { - uint32_t version = parsed_lists_meta_value.version(); + int32_t version = parsed_lists_meta_value.version(); uint64_t target_index = index >= 0 ? parsed_lists_meta_value.left_index() + index + 1 : parsed_lists_meta_value.right_index() + index; if (target_index <= parsed_lists_meta_value.left_index() || @@ -731,10 +731,10 @@ Status RedisLists::RPop(const Slice& key, int64_t count, std::vector(parsed_lists_meta_value.count()); int32_t version = parsed_lists_meta_value.version(); int32_t start_index = 0; - int32_t stop_index = count<=size?count-1:size-1; + auto stop_index = static_cast(count<=size?count-1:size-1); int32_t cur_index = 0; ListsDataKey lists_data_key(key, version, parsed_lists_meta_value.right_index()-1); rocksdb::Iterator* iter = db_->NewIterator(default_read_options_, handles_[1]); @@ -1247,7 +1247,7 @@ void RedisLists::ScanDatabase() { ScopeSnapshot ss(db_, &snapshot); iterator_options.snapshot = snapshot; iterator_options.fill_cache = false; - int32_t current_time = time(nullptr); + auto current_time = static_cast(time(nullptr)); LOG(INFO) << "***************List Meta Data***************"; auto meta_iter = db_->NewIterator(iterator_options, handles_[0]); diff --git a/src/storage/src/redis_sets.cc b/src/storage/src/redis_sets.cc index 09df49f4a6..afd2758a15 100644 --- a/src/storage/src/redis_sets.cc +++ b/src/storage/src/redis_sets.cc @@ -177,7 +177,7 @@ rocksdb::Status RedisSets::PKPatternMatchDel(const std::string& pattern, int32_t if (static_cast(batch.Count()) >= BATCH_DELETE_LIMIT) { s = db_->Write(default_write_options_, &batch); if (s.ok()) { - total_delete += batch.Count(); + total_delete += static_cast(batch.Count()); batch.Clear(); } else { *ret = total_delete; @@ -189,7 +189,7 @@ rocksdb::Status RedisSets::PKPatternMatchDel(const std::string& pattern, int32_t if (batch.Count() != 0U) { s = db_->Write(default_write_options_, &batch); if (s.ok()) { - total_delete += batch.Count(); + total_delete += static_cast(batch.Count()); batch.Clear(); } } @@ -217,13 +217,13 @@ rocksdb::Status RedisSets::SAdd(const Slice& key, const std::vector ParsedSetsMetaValue parsed_sets_meta_value(&meta_value); if (parsed_sets_meta_value.IsStale() || parsed_sets_meta_value.count() == 0) { version = parsed_sets_meta_value.InitialMetaValue(); - parsed_sets_meta_value.set_count(filtered_members.size()); + parsed_sets_meta_value.set_count(static_cast(filtered_members.size())); batch.Put(handles_[0], key, meta_value); for (const auto& member : filtered_members) { SetsMemberKey sets_member_key(key, version, member); batch.Put(handles_[1], sets_member_key.Encode(), Slice()); } - *ret = filtered_members.size(); + *ret = static_cast(filtered_members.size()); } else { int32_t cnt = 0; std::string member_value; @@ -257,7 +257,7 @@ rocksdb::Status RedisSets::SAdd(const Slice& key, const std::vector SetsMemberKey sets_member_key(key, version, member); batch.Put(handles_[1], sets_member_key.Encode(), Slice()); } - *ret = filtered_members.size(); + *ret = static_cast(filtered_members.size()); } else { return s; } @@ -420,7 +420,7 @@ rocksdb::Status RedisSets::SDiffstore(const Slice& destination, const std::vecto ParsedSetsMetaValue parsed_sets_meta_value(&meta_value); statistic = parsed_sets_meta_value.count(); version = parsed_sets_meta_value.InitialMetaValue(); - parsed_sets_meta_value.set_count(members.size()); + parsed_sets_meta_value.set_count(static_cast(members.size())); batch.Put(handles_[0], destination, meta_value); } else if (s.IsNotFound()) { char str[4]; @@ -435,7 +435,7 @@ rocksdb::Status RedisSets::SDiffstore(const Slice& destination, const std::vecto SetsMemberKey sets_member_key(destination, version, member); batch.Put(handles_[1], sets_member_key.Encode(), Slice()); } - *ret = members.size(); + *ret = static_cast(members.size()); s = db_->Write(default_write_options_, &batch); UpdateSpecificKeyStatistics(destination.ToString(), statistic); value_to_dest = std::move(members); @@ -603,7 +603,7 @@ rocksdb::Status RedisSets::SInterstore(const Slice& destination, const std::vect ParsedSetsMetaValue parsed_sets_meta_value(&meta_value); statistic = parsed_sets_meta_value.count(); version = parsed_sets_meta_value.InitialMetaValue(); - parsed_sets_meta_value.set_count(members.size()); + parsed_sets_meta_value.set_count(static_cast(members.size())); batch.Put(handles_[0], destination, meta_value); } else if (s.IsNotFound()) { char str[4]; @@ -618,7 +618,7 @@ rocksdb::Status RedisSets::SInterstore(const Slice& destination, const std::vect SetsMemberKey sets_member_key(destination, version, member); batch.Put(handles_[1], sets_member_key.Encode(), Slice()); } - *ret = members.size(); + *ret = static_cast(members.size()); s = db_->Write(default_write_options_, &batch); UpdateSpecificKeyStatistics(destination.ToString(), statistic); value_to_dest = std::move(members); @@ -821,7 +821,7 @@ rocksdb::Status RedisSets::SPop(const Slice& key, std::vector* memb cur_round < cnt; cur_round++) { do { - target_index = engine() % modnum; + target_index = static_cast( engine() % modnum); } while (sets_index.find(target_index) != sets_index.end()); sets_index.insert(target_index); } @@ -843,7 +843,7 @@ rocksdb::Status RedisSets::SPop(const Slice& key, std::vector* memb } } - parsed_sets_meta_value.ModifyCount(-cnt); + parsed_sets_meta_value.ModifyCount(static_cast(-cnt)); batch.Put(handles_[0], key, meta_value); delete iter; @@ -880,7 +880,7 @@ rocksdb::Status RedisSets::SRandmember(const Slice& key, int32_t count, std::vec } members->clear(); - int64_t last_seed = pstd::NowMicros(); + auto last_seed = pstd::NowMicros(); std::default_random_engine engine; std::string meta_value; @@ -903,8 +903,8 @@ rocksdb::Status RedisSets::SRandmember(const Slice& key, int32_t count, std::vec count = count <= size ? count : size; while (targets.size() < static_cast(count)) { engine.seed(last_seed); - last_seed = engine(); - uint32_t pos = last_seed % size; + last_seed = static_cast(engine()); + auto pos = static_cast(last_seed % size); if (unique.find(pos) == unique.end()) { unique.insert(pos); targets.push_back(pos); @@ -914,8 +914,8 @@ rocksdb::Status RedisSets::SRandmember(const Slice& key, int32_t count, std::vec count = -count; while (targets.size() < static_cast(count)) { engine.seed(last_seed); - last_seed = engine(); - targets.push_back(last_seed % size); + last_seed = static_cast(engine()); + targets.push_back(static_cast(last_seed % size)); } } std::sort(targets.begin(), targets.end()); @@ -1086,7 +1086,7 @@ rocksdb::Status RedisSets::SUnionstore(const Slice& destination, const std::vect ParsedSetsMetaValue parsed_sets_meta_value(&meta_value); statistic = parsed_sets_meta_value.count(); version = parsed_sets_meta_value.InitialMetaValue(); - parsed_sets_meta_value.set_count(members.size()); + parsed_sets_meta_value.set_count(static_cast(members.size())); batch.Put(handles_[0], destination, meta_value); } else if (s.IsNotFound()) { char str[4]; @@ -1101,7 +1101,7 @@ rocksdb::Status RedisSets::SUnionstore(const Slice& destination, const std::vect SetsMemberKey sets_member_key(destination, version, member); batch.Put(handles_[1], sets_member_key.Encode(), Slice()); } - *ret = members.size(); + *ret = static_cast(members.size()); s = db_->Write(default_write_options_, &batch); UpdateSpecificKeyStatistics(destination.ToString(), statistic); value_to_dest = std::move(members); @@ -1478,7 +1478,7 @@ void RedisSets::ScanDatabase() { ScopeSnapshot ss(db_, &snapshot); iterator_options.snapshot = snapshot; iterator_options.fill_cache = false; - int32_t current_time = time(nullptr); + auto current_time = static_cast(time(nullptr)); LOG(INFO) << "***************Sets Meta Data***************"; auto meta_iter = db_->NewIterator(iterator_options, handles_[0]); diff --git a/src/storage/src/redis_strings.cc b/src/storage/src/redis_strings.cc index 3cf5337c9a..ed745f88a7 100644 --- a/src/storage/src/redis_strings.cc +++ b/src/storage/src/redis_strings.cc @@ -138,7 +138,7 @@ Status RedisStrings::PKPatternMatchDel(const std::string& pattern, int32_t* ret) if (static_cast(batch.Count()) >= BATCH_DELETE_LIMIT) { s = db_->Write(default_write_options_, &batch); if (s.ok()) { - total_delete += batch.Count(); + total_delete += static_cast(batch.Count()); batch.Clear(); } else { *ret = total_delete; @@ -150,7 +150,7 @@ Status RedisStrings::PKPatternMatchDel(const std::string& pattern, int32_t* ret) if (batch.Count() != 0U) { s = db_->Write(default_write_options_, &batch); if (s.ok()) { - total_delete += batch.Count(); + total_delete += static_cast( batch.Count()); batch.Clear(); } } @@ -167,7 +167,7 @@ Status RedisStrings::Append(const Slice& key, const Slice& value, int32_t* ret) if (s.ok()) { ParsedStringsValue parsed_strings_value(&old_value); if (parsed_strings_value.IsStale()) { - *ret = value.size(); + *ret = static_cast(value.size()); StringsValue strings_value(value); return db_->Put(default_write_options_, key, strings_value.Encode()); } else { @@ -176,11 +176,11 @@ Status RedisStrings::Append(const Slice& key, const Slice& value, int32_t* ret) std::string new_value = old_user_value + value.ToString(); StringsValue strings_value(new_value); strings_value.set_timestamp(timestamp); - *ret = new_value.size(); + *ret = static_cast(new_value.size()); return db_->Put(default_write_options_, key, strings_value.Encode()); } } else if (s.IsNotFound()) { - *ret = value.size(); + *ret = static_cast(value.size()); StringsValue strings_value(value); return db_->Put(default_write_options_, key, strings_value.Encode()); } @@ -215,7 +215,7 @@ Status RedisStrings::BitCount(const Slice& key, int64_t start_offset, int64_t en } else { parsed_strings_value.StripSuffix(); const auto bit_value = reinterpret_cast(value.data()); - int64_t value_length = value.length(); + auto value_length = static_cast(value.length()); if (have_range) { if (start_offset < 0) { start_offset = start_offset + value_length; @@ -259,7 +259,7 @@ std::string BitOpOperate(BitOpType op, const std::vector& src_value output = 0; } if (op == kBitOpNot) { - output = ~(output); + output = static_cast(~output); } for (size_t i = 1; i < src_values.size(); i++) { if (static_cast(src_values[i].size()) - 1 >= j) { @@ -271,13 +271,13 @@ std::string BitOpOperate(BitOpType op, const std::vector& src_value case kBitOpNot: break; case kBitOpAnd: - output &= byte; + output = static_cast(output & byte); break; case kBitOpOr: - output |= byte; + output = static_cast(output | byte); break; case kBitOpXor: - output ^= byte; + output = static_cast(output ^ byte); break; case kBitOpDefault: break; @@ -312,7 +312,7 @@ Status RedisStrings::BitOp(BitOpType op, const std::string& dest_key, const std: } else { parsed_strings_value.StripSuffix(); src_values.push_back(value); - value_len = value.size(); + value_len = static_cast(value.size()); } } else if (s.IsNotFound()) { src_values.emplace_back(""); @@ -325,9 +325,9 @@ Status RedisStrings::BitOp(BitOpType op, const std::string& dest_key, const std: std::string dest_value = BitOpOperate(op, src_values, max_len); value_to_dest = dest_value; - *ret = dest_value.size(); + *ret = static_cast(dest_value.size()); - StringsValue strings_value(Slice(dest_value.c_str(), static_cast(max_len))); + StringsValue strings_value(Slice(dest_value.c_str(), max_len)); ScopeRecordLock l(lock_mgr_, dest_key); return db_->Put(default_write_options_, dest_key, strings_value.Encode()); } @@ -423,7 +423,7 @@ Status RedisStrings::Getrange(const Slice& key, int64_t start_offset, int64_t en return Status::NotFound("Stale"); } else { parsed_strings_value.StripSuffix(); - int64_t size = value.size(); + auto size = static_cast(value.size()); int64_t start_t = start_offset >= 0 ? start_offset : size + start_offset; int64_t end_t = end_offset >= 0 ? end_offset : size + end_offset; if (start_t > size - 1 || (start_t != 0 && start_t > end_t) || (start_t != 0 && end_t < 0)) { @@ -678,8 +678,8 @@ Status RedisStrings::SetBit(const Slice& key, int64_t offset, int32_t on, int32_ if (*ret == on) { return Status::OK(); } - byte_val &= static_cast(~(1 << bit)); - byte_val |= static_cast((on & 0x1) << bit); + byte_val = static_cast(byte_val & (~(1 << bit))); + byte_val = static_cast(byte_val | ((on & 0x1) << bit)); if (byte + 1 <= value_lenth) { data_value.replace(byte, 1, &byte_val, 1); } else { @@ -808,7 +808,7 @@ Status RedisStrings::Setrange(const Slice& key, int64_t start_offset, const Slic if (parsed_strings_value.IsStale()) { std::string tmp(start_offset, '\0'); new_value = tmp.append(value.data()); - *ret = new_value.length(); + *ret = static_cast(new_value.length()); } else { if (static_cast(start_offset) > old_value.length()) { old_value.resize(start_offset); @@ -822,13 +822,13 @@ Status RedisStrings::Setrange(const Slice& key, int64_t start_offset, const Slic new_value = head + value.data() + tail; } } - *ret = new_value.length(); + *ret = static_cast(new_value.length()); StringsValue strings_value(new_value); return db_->Put(default_write_options_, key, strings_value.Encode()); } else if (s.IsNotFound()) { std::string tmp(start_offset, '\0'); new_value = tmp.append(value.data()); - *ret = new_value.length(); + *ret = static_cast(new_value.length()); StringsValue strings_value(new_value); return db_->Put(default_write_options_, key, strings_value.Encode()); } @@ -839,7 +839,7 @@ Status RedisStrings::Strlen(const Slice& key, int32_t* len) { std::string value; Status s = Get(key, &value); if (s.ok()) { - *len = value.size(); + *len = static_cast(value.size()); } else { *len = 0; } @@ -864,7 +864,7 @@ int32_t GetBitPos(const unsigned char* s, unsigned int bytes, int bit) { } l++; bytes = bytes - sizeof(*l); - pos = pos + 8 * sizeof(*l); + pos += static_cast(8 * sizeof(*l)); } auto c = reinterpret_cast(l); for (size_t j = 0; j < sizeof(*l); j++) { @@ -908,7 +908,7 @@ Status RedisStrings::BitPos(const Slice& key, int32_t bit, int64_t* ret) { } else { parsed_strings_value.StripSuffix(); const auto bit_value = reinterpret_cast(value.data()); - int64_t value_length = value.length(); + auto value_length = static_cast(value.length()); int64_t start_offset = 0; int64_t end_offset = std::max(value_length - 1, static_cast(0)); int64_t bytes = end_offset - start_offset + 1; @@ -943,7 +943,7 @@ Status RedisStrings::BitPos(const Slice& key, int32_t bit, int64_t start_offset, } else { parsed_strings_value.StripSuffix(); const auto bit_value = reinterpret_cast(value.data()); - int64_t value_length = value.length(); + auto value_length = static_cast(value.length()); int64_t end_offset = std::max(value_length - 1, static_cast(0)); if (start_offset < 0) { start_offset = start_offset + value_length; @@ -991,7 +991,7 @@ Status RedisStrings::BitPos(const Slice& key, int32_t bit, int64_t start_offset, } else { parsed_strings_value.StripSuffix(); const auto bit_value = reinterpret_cast(value.data()); - int64_t value_length = value.length(); + auto value_length = static_cast(value.length()); if (start_offset < 0) { start_offset = start_offset + value_length; } @@ -1333,7 +1333,7 @@ void RedisStrings::ScanDatabase() { ScopeSnapshot ss(db_, &snapshot); iterator_options.snapshot = snapshot; iterator_options.fill_cache = false; - int32_t current_time = time(nullptr); + auto current_time = static_cast(time(nullptr)); LOG(INFO) << "***************String Data***************"; auto iter = db_->NewIterator(iterator_options); diff --git a/src/storage/src/redis_zsets.cc b/src/storage/src/redis_zsets.cc index 80d8ce11d1..e057d4ebad 100644 --- a/src/storage/src/redis_zsets.cc +++ b/src/storage/src/redis_zsets.cc @@ -190,7 +190,7 @@ Status RedisZSets::PKPatternMatchDel(const std::string& pattern, int32_t* ret) { if (static_cast(batch.Count()) >= BATCH_DELETE_LIMIT) { s = db_->Write(default_write_options_, &batch); if (s.ok()) { - total_delete += batch.Count(); + total_delete += static_cast(batch.Count()); batch.Clear(); } else { *ret = total_delete; @@ -202,7 +202,7 @@ Status RedisZSets::PKPatternMatchDel(const std::string& pattern, int32_t* ret) { if (batch.Count() != 0U) { s = db_->Write(default_write_options_, &batch); if (s.ok()) { - total_delete += batch.Count(); + total_delete += static_cast(batch.Count()); batch.Clear(); } } @@ -225,7 +225,7 @@ Status RedisZSets::ZPopMax(const Slice& key, const int64_t count, std::vector::max(), Slice()); @@ -267,7 +267,7 @@ Status RedisZSets::ZPopMin(const Slice& key, const int64_t count, std::vector::lowest(), Slice()); @@ -378,7 +378,7 @@ Status RedisZSets::ZAdd(const Slice& key, const std::vector& score_ ZSetsScoreKey zsets_score_key(key, version, sm.score, sm.member); batch.Put(handles_[2], zsets_score_key.Encode(), Slice()); } - *ret = filtered_score_members.size(); + *ret = static_cast(filtered_score_members.size()); } else { return s; } @@ -1093,7 +1093,7 @@ Status RedisZSets::ZUnionstore(const Slice& destination, const std::vector(member_score_map.size())); batch.Put(handles_[0], destination, meta_value); } else { char buf[4]; @@ -1114,7 +1114,7 @@ Status RedisZSets::ZUnionstore(const Slice& destination, const std::vector(member_score_map.size()); s = db_->Write(default_write_options_, &batch); UpdateSpecificKeyStatistics(destination.ToString(), statistic); value_to_dest = std::move(member_score_map); @@ -1220,7 +1220,7 @@ Status RedisZSets::ZInterstore(const Slice& destination, const std::vector(final_score_members.size())); batch.Put(handles_[0], destination, meta_value); } else { char buf[4]; @@ -1240,7 +1240,7 @@ Status RedisZSets::ZInterstore(const Slice& destination, const std::vector(final_score_members.size()); s = db_->Write(default_write_options_, &batch); UpdateSpecificKeyStatistics(destination.ToString(), statistic); value_to_dest = std::move(final_score_members); @@ -1299,7 +1299,7 @@ Status RedisZSets::ZLexcount(const Slice& key, const Slice& min, const Slice& ma int32_t* ret) { std::vector members; Status s = ZRangebylex(key, min, max, left_close, right_close, &members); - *ret = members.size(); + *ret = static_cast(members.size()); return s; } @@ -1744,7 +1744,7 @@ void RedisZSets::ScanDatabase() { ScopeSnapshot ss(db_, &snapshot); iterator_options.snapshot = snapshot; iterator_options.fill_cache = false; - int32_t current_time = time(nullptr); + auto current_time = static_cast(time(nullptr)); LOG(INFO) << "***************ZSets Meta Data***************"; auto meta_iter = db_->NewIterator(iterator_options, handles_[0]); diff --git a/src/storage/src/storage.cc b/src/storage/src/storage.cc index ff72d19c1d..b6389add2b 100644 --- a/src/storage/src/storage.cc +++ b/src/storage/src/storage.cc @@ -885,8 +885,8 @@ int64_t Storage::PKExpireScan(const DataType& dtype, int64_t cursor, int32_t min start_key.erase(start_key.begin()); switch (key_type) { case 'k': - is_finish = - strings_db_->PKExpireScan(start_key, curtime + min_ttl, curtime + max_ttl, keys, &leftover_visits, &next_key); + is_finish = strings_db_->PKExpireScan(start_key, static_cast(curtime + min_ttl), + static_cast(curtime + max_ttl), keys, &leftover_visits, &next_key); if ((leftover_visits == 0) && !is_finish) { cursor_ret = cursor + step_length; StoreCursorStartKey(dtype, cursor_ret, std::string("k") + next_key); @@ -903,8 +903,8 @@ int64_t Storage::PKExpireScan(const DataType& dtype, int64_t cursor, int32_t min } start_key = ""; case 'h': - is_finish = - hashes_db_->PKExpireScan(start_key, curtime + min_ttl, curtime + max_ttl, keys, &leftover_visits, &next_key); + is_finish = hashes_db_->PKExpireScan(start_key, static_cast(curtime + min_ttl), + static_cast(curtime + max_ttl), keys, &leftover_visits, &next_key); if ((leftover_visits == 0) && !is_finish) { cursor_ret = cursor + step_length; StoreCursorStartKey(dtype, cursor_ret, std::string("h") + next_key); @@ -921,8 +921,8 @@ int64_t Storage::PKExpireScan(const DataType& dtype, int64_t cursor, int32_t min } start_key = ""; case 's': - is_finish = - sets_db_->PKExpireScan(start_key, curtime + min_ttl, curtime + max_ttl, keys, &leftover_visits, &next_key); + is_finish = sets_db_->PKExpireScan(start_key, static_cast(curtime + min_ttl), + static_cast(curtime + max_ttl), keys, &leftover_visits, &next_key); if ((leftover_visits == 0) && !is_finish) { cursor_ret = cursor + step_length; StoreCursorStartKey(dtype, cursor_ret, std::string("s") + next_key); @@ -939,8 +939,8 @@ int64_t Storage::PKExpireScan(const DataType& dtype, int64_t cursor, int32_t min } start_key = ""; case 'l': - is_finish = - lists_db_->PKExpireScan(start_key, curtime + min_ttl, curtime + max_ttl, keys, &leftover_visits, &next_key); + is_finish = lists_db_->PKExpireScan(start_key, static_cast(curtime + min_ttl), + static_cast(curtime + max_ttl), keys, &leftover_visits, &next_key); if ((leftover_visits == 0) && !is_finish) { cursor_ret = cursor + step_length; StoreCursorStartKey(dtype, cursor_ret, std::string("l") + next_key); @@ -957,8 +957,8 @@ int64_t Storage::PKExpireScan(const DataType& dtype, int64_t cursor, int32_t min } start_key = ""; case 'z': - is_finish = - zsets_db_->PKExpireScan(start_key, curtime + min_ttl, curtime + max_ttl, keys, &leftover_visits, &next_key); + is_finish = zsets_db_->PKExpireScan(start_key, static_cast(curtime + min_ttl), + static_cast(curtime + max_ttl), keys, &leftover_visits, &next_key); if ((leftover_visits == 0) && !is_finish) { cursor_ret = cursor + step_length; StoreCursorStartKey(dtype, cursor_ret, std::string("z") + next_key); diff --git a/src/storage/src/util.cc b/src/storage/src/util.cc index 35089be4b3..8ad58ff168 100644 --- a/src/storage/src/util.cc +++ b/src/storage/src/util.cc @@ -44,6 +44,10 @@ int StringMatch(const char* pattern, int pattern_len, const char* str, int strin return pstd::stringmatchlen(pattern, pattern_len, str, string_len, nocase); } +int StringMatch(const char* pattern, uint64_t pattern_len, const char* str, uint64_t string_len, int nocase) { + return pstd::stringmatchlen(pattern, static_cast(pattern_len), str, static_cast(string_len), nocase); +} + int StrToLongDouble(const char* s, size_t slen, long double* ldval) { char* pEnd; std::string t(s, slen); @@ -212,7 +216,7 @@ int CalculateMetaStartAndEndKey(const std::string& key, std::string* meta_start_ std::strncpy(dst.get(), key.data(), key.size()); char* dst_ptr = dst.get() + key.size(); meta_start_key->assign(start, key.size()); - *dst_ptr = static_cast(0xff); + *dst_ptr = static_cast(0xff); meta_end_key->assign(start, key.size() + 1); return 0; } @@ -227,7 +231,7 @@ int CalculateDataStartAndEndKey(const std::string& key, std::string* data_start_ dst_ptr += sizeof(int32_t); std::strncpy(dst_ptr, key.data(), key.size()); dst_ptr += key.size(); - *dst_ptr = static_cast(0xff); + *dst_ptr = static_cast(0xff); data_start_key->assign(start, sizeof(int32_t) + key.size()); data_end_key->assign(start, sizeof(int32_t) + key.size() + 1);