refactor: replace boost lexical_cast

src/apiserver/api_server_impl.cc

@@ -263,7 +263,7 @@ bool APIServerImpl::AppendJsonValue(const Value& v, hybridse::sdk::DataType type
             if (!v.IsInt()) {
                 return false;
             }
-            return row->AppendInt16(boost::lexical_cast<int16_t>(v.GetInt()));
+            return row->AppendInt16(static_cast<int16_t>(v.GetInt()));
         }
         case hybridse::sdk::kTypeInt32: {
             if (!v.IsInt()) {

src/codec/codec.cc

@@ -18,10 +18,10 @@
 
 #include <algorithm>
 #include <array>
+#include <charconv>
 #include <unordered_set>
 
 #include "base/glog_wrapper.h"
-#include "boost/lexical_cast.hpp"
 
 namespace openmldb {
 namespace codec {
@@ -463,23 +463,43 @@ bool RowBuilder::AppendValue(const std::string& val) {
                 }
                 break;
             }
-            case openmldb::type::kSmallInt:
-                ok = AppendInt16(boost::lexical_cast<int16_t>(val));
+            case openmldb::type::kSmallInt: {
+                int16_t v = 0;
+                if (auto ret = std::from_chars(val.data(), val.data() + val.size(), v); ret.ec != std::errc()) {
+                    return false;
+                }
+                ok = AppendInt16(v);
                 break;
-            case openmldb::type::kInt:
-                ok = AppendInt32(boost::lexical_cast<int32_t>(val));
+            }
+            case openmldb::type::kInt: {
+                int32_t v = 0;
+                if (auto ret = std::from_chars(val.data(), val.data() + val.size(), v); ret.ec != std::errc()) {
+                    return false;
+                }
+                ok = AppendInt32(v);
                 break;
-            case openmldb::type::kBigInt:
-                ok = AppendInt64(boost::lexical_cast<int64_t>(val));
+            }
+            case openmldb::type::kBigInt: {
+                int64_t v = 0;
+                if (auto ret = std::from_chars(val.data(), val.data() + val.size(), v); ret.ec != std::errc()) {
+                    return false;
+                }
+                ok = AppendInt64(v);
                 break;
-            case openmldb::type::kTimestamp:
-                ok = AppendTimestamp(boost::lexical_cast<int64_t>(val));
+            }
+            case openmldb::type::kTimestamp: {
+                int64_t v = 0;
+                if (auto ret = std::from_chars(val.data(), val.data() + val.size(), v); ret.ec != std::errc()) {
+                    return false;
+                }
+                ok = AppendTimestamp(v);
                 break;
+            }
             case openmldb::type::kFloat:
-                ok = AppendFloat(boost::lexical_cast<float>(val));
+                ok = AppendFloat(std::stof(val));
                 break;
             case openmldb::type::kDouble:
-                ok = AppendDouble(boost::lexical_cast<double>(val));
+                ok = AppendDouble(std::stod(val));
                 break;
             case openmldb::type::kDate: {
                 std::vector<std::string> parts;
@@ -488,9 +508,18 @@ bool RowBuilder::AppendValue(const std::string& val) {
                     ok = false;
                     break;
                 }
-                uint32_t year = boost::lexical_cast<uint32_t>(parts[0]);
-                uint32_t mon = boost::lexical_cast<uint32_t>(parts[1]);
-                uint32_t day = boost::lexical_cast<uint32_t>(parts[2]);
+                uint32_t year = 0;
+                uint32_t mon = 0;
+                uint32_t day = 0;
+                if (auto ret = std::from_chars(parts[0].data(), parts[0].data() + parts[0].size(), year); ret.ec != std::errc()) {
+                    return false;
+                }
+                if (auto ret = std::from_chars(parts[1].data(), parts[1].data() + parts[1].size(), mon); ret.ec != std::errc()) {
+                    return false;
+                }
+                if (auto ret = std::from_chars(parts[2].data(), parts[2].data() + parts[2].size(), day); ret.ec != std::errc()) {
+                    return false;
+                }
                 ok = AppendDate(year, mon, day);
                 break;
             }

src/codec/field_codec.h

@@ -20,12 +20,12 @@
 #include <string.h>
 
 #include <algorithm>
+#include <charconv>
 #include <string>
 #include <vector>
 
 #include "base/endianconv.h"
 #include "base/strings.h"
-#include "boost/lexical_cast.hpp"
 #include "proto/type.pb.h"
 #include "sdk/base.h"
 
@@ -56,19 +56,31 @@ static bool AppendColumnValue(const std::string& v, hybridse::sdk::DataType type
                 return ok;
             }
             case hybridse::sdk::kTypeInt16: {
-                return row->AppendInt16(boost::lexical_cast<int16_t>(v));
+                int16_t val = 0;
+                if (auto ret = std::from_chars(v.data(), v.data() + v.size(), val); ret.ec != std::errc()) {
+                    return false;
+                }
+                return row->AppendInt16(val);
             }
             case hybridse::sdk::kTypeInt32: {
-                return row->AppendInt32(boost::lexical_cast<int32_t>(v));
+                int32_t val = 0;
+                if (auto ret = std::from_chars(v.data(), v.data() + v.size(), val); ret.ec != std::errc()) {
+                    return false;
+                }
+                return row->AppendInt32(val);
             }
             case hybridse::sdk::kTypeInt64: {
-                return row->AppendInt64(boost::lexical_cast<int64_t>(v));
+                int64_t val = 0;
+                if (auto ret = std::from_chars(v.data(), v.data() + v.size(), val); ret.ec != std::errc()) {
+                    return false;
+                }
+                return row->AppendInt64(val);
             }
             case hybridse::sdk::kTypeFloat: {
-                return row->AppendFloat(boost::lexical_cast<float>(v));
+                return row->AppendFloat(std::stof(v));
             }
             case hybridse::sdk::kTypeDouble: {
-                return row->AppendDouble(boost::lexical_cast<double>(v));
+                return row->AppendDouble(std::stod(v));
             }
             case hybridse::sdk::kTypeString: {
                 return row->AppendString(v);
@@ -79,13 +91,29 @@ static bool AppendColumnValue(const std::string& v, hybridse::sdk::DataType type
                 if (parts.size() != 3) {
                     return false;
                 }
-                auto year = boost::lexical_cast<int32_t>(parts[0]);
-                auto mon = boost::lexical_cast<int32_t>(parts[1]);
-                auto day = boost::lexical_cast<int32_t>(parts[2]);
+                int32_t year = 0;
+                int32_t mon = 0;
+                int32_t day = 0;
+                if (auto ret = std::from_chars(parts[0].data(), parts[0].data() + parts[0].size(), year);
+                    ret.ec != std::errc()) {
+                    return false;
+                }
+                if (auto ret = std::from_chars(parts[1].data(), parts[1].data() + parts[1].size(), mon);
+                    ret.ec != std::errc()) {
+                    return false;
+                }
+                if (auto ret = std::from_chars(parts[2].data(), parts[2].data() + parts[2].size(), day);
+                    ret.ec != std::errc()) {
+                    return false;
+                }
                 return row->AppendDate(year, mon, day);
             }
             case hybridse::sdk::kTypeTimestamp: {
-                return row->AppendTimestamp(boost::lexical_cast<int64_t>(v));
+                int64_t val = 0;
+                if (auto ret = std::from_chars(v.data(), v.data() + v.size(), val); ret.ec != std::errc()) {
+                    return false;
+                }
+                return row->AppendTimestamp(val);
             }
             default: {
                 return false;

src/sdk/node_adapter.cc

@@ -675,20 +675,42 @@ std::shared_ptr<hybridse::node::ConstNode> NodeAdapter::StringToData(const std::
                                                                      openmldb::type::DataType data_type) {
     try {
         switch (data_type) {
-            case type::kBool:
-                return std::make_shared<hybridse::node::ConstNode>(boost::lexical_cast<bool>(str));
-            case type::kSmallInt:
-                return std::make_shared<hybridse::node::ConstNode>(boost::lexical_cast<int16_t>(str));
+            case type::kBool: {
+                std::string b_val = str;              
+                std::transform(b_val.begin(), b_val.end(), b_val.begin(), ::tolower);
+                if (b_val == "true") {
+                    return std::make_shared<hybridse::node::ConstNode>(true);
+                } else {
+                    return std::make_shared<hybridse::node::ConstNode>(false);
+                }
+            }
+            case type::kSmallInt: {
+                int16_t val = 0;
+                if (auto ret = std::from_chars(str.data(), str.data() + str.size(), val); ret.ec != std::errc()) {
+                    return std::shared_ptr<hybridse::node::ConstNode>();
+                }
+                return std::make_shared<hybridse::node::ConstNode>(val);
+            }
             case type::kInt:
-            case type::kDate:
-                return std::make_shared<hybridse::node::ConstNode>(boost::lexical_cast<int32_t>(str));
+            case type::kDate: {
+                int32_t val = 0;
+                if (auto ret = std::from_chars(str.data(), str.data() + str.size(), val); ret.ec != std::errc()) {
+                    return std::shared_ptr<hybridse::node::ConstNode>();
+                }
+                return std::make_shared<hybridse::node::ConstNode>(val);
+            }
             case type::kBigInt:
-            case type::kTimestamp:
-                return std::make_shared<hybridse::node::ConstNode>(boost::lexical_cast<int64_t>(str));
+            case type::kTimestamp: {
+                int64_t val = 0;
+                if (auto ret = std::from_chars(str.data(), str.data() + str.size(), val); ret.ec != std::errc()) {
+                    return std::shared_ptr<hybridse::node::ConstNode>();
+                }
+                return std::make_shared<hybridse::node::ConstNode>(val);
+            }
             case type::kFloat:
-                return std::make_shared<hybridse::node::ConstNode>(boost::lexical_cast<float>(str));
+                return std::make_shared<hybridse::node::ConstNode>(std::stof(str));
             case type::kDouble:
-                return std::make_shared<hybridse::node::ConstNode>(boost::lexical_cast<double>(str));
+                return std::make_shared<hybridse::node::ConstNode>(std::stod(str));
             case type::kVarchar:
             case type::kString:
                 return std::make_shared<hybridse::node::ConstNode>(str);

src/tablet/tablet_impl_test.cc

@@ -31,7 +31,6 @@
 #include "base/glog_wrapper.h"
 #include "base/kv_iterator.h"
 #include "base/strings.h"
-#include "boost/lexical_cast.hpp"
 #include "codec/codec.h"
 #include "codec/row_codec.h"
 #include "codec/schema_codec.h"

src/test/base_test.cc

@@ -15,8 +15,7 @@
  */
 
 #include "test/base_test.h"
-
-#include "boost/lexical_cast.hpp"
+#include <charconv>
 #include "glog/logging.h"
 #include "sdk/base.h"
 #include "sdk/result_set.h"
@@ -255,8 +254,10 @@ const std::vector<hybridse::codec::Row> SQLCaseTest::SortRows(const hybridse::vm
         std::vector<std::pair<int64_t, hybridse::codec::Row>> sort_rows;
         for (auto row : rows) {
             row_view.Reset(row.buf());
-            row_view.GetAsString(idx);
-            sort_rows.push_back(std::make_pair(boost::lexical_cast<int64_t>(row_view.GetAsString(idx)), row));
+            std::string str = row_view.GetAsString(idx);
+            int64_t val = 0;
+            std::from_chars(str.data(), str.data() + str.size(), val);
+            sort_rows.push_back(std::make_pair(val, row));
         }
         std::sort(sort_rows.begin(), sort_rows.end(),
                   [](std::pair<int64_t, hybridse::codec::Row> &a, std::pair<int64_t, hybridse::codec::Row> &b) {

src/zk/zk_client.cc

@@ -17,13 +17,13 @@
 #include "zk/zk_client.h"
 
 #include <algorithm>
+#include <charconv>
 #include <utility>
 
 #include "absl/cleanup/cleanup.h"
 #include "absl/strings/str_split.h"
 #include "base/glog_wrapper.h"
 #include "base/strings.h"
-#include "boost/lexical_cast.hpp"
 #include "gflags/gflags.h"
 
 namespace openmldb {
@@ -435,9 +435,8 @@ bool ZkClient::Increment(const std::string& node) {
             continue;
         }
         uint64_t number = 0;
-        try {
-            number = boost::lexical_cast<uint64_t>(value);
-        } catch (const std::exception& e) {
+        auto result = std::from_chars(value.data(), value.data() + value.size(), number);
+        if (result.ec != std::errc{}) {
             return false;
         }
         std::string new_value = std::to_string(number + 1);