hikyuu 2.1.0__cp312-none-win_amd64.whl → 2.1.2__cp312-none-win_amd64.whl

hikyuu/include/hikyuu/utilities/datetime/Datetime.h

@@ -17,14 +17,19 @@
 #include <string>
 #include <vector>
 #include <fmt/ostream.h>
+
+#include "hikyuu/utilities/config.h"
+#if !HKU_SUPPORT_DATETIME
+#error "Don't support datetime, you can config with --datetime=y"
+#endif
 #include "TimeDelta.h"
 
 #if defined(_MSC_VER)
 #pragma warning(disable : 4251)
 #endif
 
-#ifndef HKU_API
-#define HKU_API
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
 #endif
 
 namespace hku {
@@ -37,7 +42,7 @@ namespace bd = boost::gregorian;
  * @details 构造失败将抛出异常 std::out_of_range
  * @ingroup DataType
  */
-class HKU_API Datetime {
+class HKU_UTILS_API Datetime {
 public:
     /** 返回所能表示的最小日期：1400-Jan-01 00:00:00 */
     static Datetime min();
@@ -61,7 +66,7 @@ public:
     /** 默认构造函数，Null<Datetime> */
     Datetime();
 
-    Datetime(const Datetime&);
+    Datetime(const Datetime &);
 
     /**
      * 构造函数
@@ -78,10 +83,10 @@ public:
              long millisec = 0, long microsec = 0);
 
     /** 从boost::gregorian::date构造日期类型 */
-    explicit Datetime(const bd::date&);
+    explicit Datetime(const bd::date &);
 
     /** 从boost::posix_time::ptime构造 */
-    explicit Datetime(const bt::ptime&);
+    explicit Datetime(const bt::ptime &);
 
     /**
      * 通过数字方式构造日期类型
@@ -101,11 +106,12 @@ public:
      *     2、"20010101"
      *     3、"2001-01-01 18:00:00.12345"
      *     4、"20010101T181159"
+     *     5、"20240822 11:30:06.230"
      * </pre>
      */
-    explicit Datetime(const std::string&);
+    explicit Datetime(const std::string &);
 
-    Datetime& operator=(const Datetime&);
+    Datetime &operator=(const Datetime &);
 
     /** 年份，如果是 Null 将抛出异常 */
     long year() const;
@@ -283,7 +289,7 @@ private:
     bt::ptime m_data;
 };
 
-HKU_API std::ostream& operator<<(std::ostream&, const Datetime&);
+HKU_UTILS_API std::ostream &operator<<(std::ostream &, const Datetime &);
 
 /**
  * 日期列表
@@ -297,41 +303,41 @@ typedef std::vector<Datetime> DatetimeList;
  * @param end 结束日期
  * @return [start, end)范围内的日历日期
  */
-DatetimeList HKU_API getDateRange(const Datetime& start, const Datetime& end);
+DatetimeList HKU_UTILS_API getDateRange(const Datetime &start, const Datetime &end);
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // 关系比较函数, 不直接在类中定义是为了支持 Null<>() == d，Null可以放在左边
 //
 ///////////////////////////////////////////////////////////////////////////////
-bool operator==(const Datetime&, const Datetime&);
-bool operator!=(const Datetime&, const Datetime&);
-bool operator>(const Datetime&, const Datetime&);
-bool operator<(const Datetime&, const Datetime&);
-bool operator>=(const Datetime&, const Datetime&);
-bool operator<=(const Datetime&, const Datetime&);
-
-inline bool operator==(const Datetime& d1, const Datetime& d2) {
+bool operator==(const Datetime &, const Datetime &);
+bool operator!=(const Datetime &, const Datetime &);
+bool operator>(const Datetime &, const Datetime &);
+bool operator<(const Datetime &, const Datetime &);
+bool operator>=(const Datetime &, const Datetime &);
+bool operator<=(const Datetime &, const Datetime &);
+
+inline bool operator==(const Datetime &d1, const Datetime &d2) {
     return d1.ptime() == d2.ptime();
 }
 
-inline bool operator!=(const Datetime& d1, const Datetime& d2) {
+inline bool operator!=(const Datetime &d1, const Datetime &d2) {
     return d1.ptime() != d2.ptime();
 }
 
-inline bool operator>(const Datetime& d1, const Datetime& d2) {
+inline bool operator>(const Datetime &d1, const Datetime &d2) {
     return d1.ptime() > d2.ptime();
 }
 
-inline bool operator<(const Datetime& d1, const Datetime& d2) {
+inline bool operator<(const Datetime &d1, const Datetime &d2) {
     return d1.ptime() < d2.ptime();
 }
 
-inline bool operator>=(const Datetime& d1, const Datetime& d2) {
+inline bool operator>=(const Datetime &d1, const Datetime &d2) {
     return d1.ptime() >= d2.ptime();
 }
 
-inline bool operator<=(const Datetime& d1, const Datetime& d2) {
+inline bool operator<=(const Datetime &d1, const Datetime &d2) {
     return d1.ptime() <= d2.ptime();
 }
 
@@ -340,11 +346,11 @@ inline bool operator<=(const Datetime& d1, const Datetime& d2) {
 // 加、减法运算补充
 //
 ///////////////////////////////////////////////////////////////////////////////
-inline Datetime operator+(const TimeDelta& delta, const Datetime& date) {
+inline Datetime operator+(const TimeDelta &delta, const Datetime &date) {
     return date + delta;
 }
 
-inline TimeDelta operator-(const Datetime& d1, const Datetime& d2) {
+inline TimeDelta operator-(const Datetime &d1, const Datetime &d2) {
     return TimeDelta(d1.ptime() - d2.ptime());
 }
 
@@ -359,11 +365,11 @@ inline Datetime::Datetime() {
     m_data = bt::ptime(d, bt::time_duration(0, 0, 0));
 }
 
-inline Datetime::Datetime(const Datetime& d) : m_data(d.m_data) {}
+inline Datetime::Datetime(const Datetime &d) : m_data(d.m_data) {}
 
-inline Datetime::Datetime(const bd::date& d) : m_data(bt::ptime(d, bt::time_duration(0, 0, 0))) {}
+inline Datetime::Datetime(const bd::date &d) : m_data(bt::ptime(d, bt::time_duration(0, 0, 0))) {}
 
-inline Datetime::Datetime(const bt::ptime& d) : m_data(d) {}
+inline Datetime::Datetime(const bt::ptime &d) : m_data(d) {}
 
 inline bt::ptime Datetime::ptime() const {
     return m_data;
@@ -404,21 +410,26 @@ namespace std {
 template <>
 class hash<hku::Datetime> {
 public:
-    size_t operator()(hku::Datetime const& d) const noexcept {
+    size_t operator()(hku::Datetime const &d) const noexcept {
         return d.ticks();  // or use boost::hash_combine
     }
 };
+
+inline string to_string(const hku::Datetime &date) {
+    return date.str();
+}
+
 }  // namespace std
 
 #if FMT_VERSION >= 90000
 template <>
 struct fmt::formatter<hku::Datetime> {
-    constexpr auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    constexpr auto parse(format_parse_context &ctx) -> decltype(ctx.begin()) {
         return ctx.end();
     }
 
     template <typename FormatContext>
-    auto format(const hku::Datetime& d, FormatContext& ctx) const -> decltype(ctx.out()) {
+    auto format(const hku::Datetime &d, FormatContext &ctx) const -> decltype(ctx.out()) {
         return fmt::format_to(ctx.out(), "{}", d.str());
     }
 };

hikyuu/include/hikyuu/utilities/datetime/TimeDelta.h

@@ -20,8 +20,8 @@
 #include <fmt/ostream.h>
 #include <boost/date_time/posix_time/posix_time.hpp>
 
-#ifndef HKU_API
-#define HKU_API
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
 #endif
 
 namespace hku {
@@ -33,7 +33,7 @@ namespace bd = boost::gregorian;
  * 时长，用于时间计算
  * @ingroup DataType
  */
-class HKU_API TimeDelta {
+class HKU_UTILS_API TimeDelta {
 public:
     /**
      * 构造函数
@@ -58,11 +58,14 @@ public:
     /** 通过 boost::posix_time::time_duration 构造 */
     explicit TimeDelta(bt::time_duration td);
 
+    /** 从字符串构造，格式：-1 days, hh:mm:ss.000000) */
+    explicit TimeDelta(const std::string& delta);
+
     /** 赋值构造函数 */
-    TimeDelta(const TimeDelta&) = default;
+    TimeDelta(const TimeDelta &) = default;
 
     /** 赋值拷贝函数 */
-    TimeDelta& operator=(const TimeDelta& other) {
+    TimeDelta &operator=(const TimeDelta &other) {
         if (this != &other) {
             m_duration = other.m_duration;
         }
@@ -259,8 +262,8 @@ private:
     static constexpr const int64_t m_one_day_ticks = 24 * 60 * 60 * 1000000LL;
 };
 
-std::ostream& operator<<(std::ostream& out, TimeDelta td);
-inline std::ostream& operator<<(std::ostream& out, TimeDelta td) {
+std::ostream &operator<<(std::ostream &out, TimeDelta td);
+inline std::ostream &operator<<(std::ostream &out, TimeDelta td) {
     out << td.str();
     return out;
 }
@@ -280,28 +283,28 @@ inline TimeDelta Days(int64_t days) {
  * @param hours 小时数
  * @ingroup DataType
  */
-TimeDelta HKU_API Hours(int64_t hours);
+TimeDelta HKU_UTILS_API Hours(int64_t hours);
 
 /**
  * TimeDelta 快捷创建函数
  * @param mins 分钟数
  * @ingroup DataType
  */
-TimeDelta HKU_API Minutes(int64_t mins);
+TimeDelta HKU_UTILS_API Minutes(int64_t mins);
 
 /**
  * TimeDelta 快捷创建函数
  * @param secs 秒数
  * @ingroup DataType
  */
-TimeDelta HKU_API Seconds(int64_t secs);
+TimeDelta HKU_UTILS_API Seconds(int64_t secs);
 
 /**
  * TimeDelta 快捷创建函数
  * @param milliseconds 毫秒数
  * @ingroup DataType
  */
-TimeDelta HKU_API Milliseconds(int64_t milliseconds);
+TimeDelta HKU_UTILS_API Milliseconds(int64_t milliseconds);
 
 /**
  * TimeDelta 快捷创建函数
@@ -315,15 +318,23 @@ inline TimeDelta Microseconds(int64_t microsecs) {
 
 } /* namespace hku */
 
+namespace std {
+
+inline string to_string(const hku::TimeDelta &delta) {
+    return delta.str();
+}
+
+}  // namespace std
+
 #if FMT_VERSION >= 90000
 template <>
 struct fmt::formatter<hku::TimeDelta> {
-    constexpr auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    constexpr auto parse(format_parse_context &ctx) -> decltype(ctx.begin()) {
         return ctx.end();
     }
 
     template <typename FormatContext>
-    auto format(const hku::TimeDelta& d, FormatContext& ctx) const -> decltype(ctx.out()) {
+    auto format(const hku::TimeDelta &d, FormatContext &ctx) const -> decltype(ctx.out()) {
         return fmt::format_to(ctx.out(), "{}", d.str());
     }
 };

hikyuu/include/hikyuu/utilities/db_connect/DBCondition.h

@@ -13,23 +13,23 @@
 #include <vector>
 #include <fmt/format.h>
 #include <fmt/ranges.h>
-#include "../../Log.h"
+#include "hikyuu/utilities/Log.h"
 
-#ifndef HKU_API
-#define HKU_API
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
 #endif
 
 namespace hku {
 
 struct ASC {
-    explicit ASC(const char* name) : name(name) {}
-    explicit ASC(const std::string& name) : name(name) {}
+    explicit ASC(const char *name) : name(name) {}
+    explicit ASC(const std::string &name) : name(name) {}
     std::string name;
 };
 
 struct DESC {
-    explicit DESC(const char* name) : name(name) {}
-    explicit DESC(const std::string& name) : name(name) {}
+    explicit DESC(const char *name) : name(name) {}
+    explicit DESC(const std::string &name) : name(name) {}
     std::string name;
 };
 
@@ -38,50 +38,50 @@ struct LIMIT {
     int limit = 1;
 };
 
-class HKU_API DBCondition {
+class HKU_UTILS_API DBCondition {
 public:
     DBCondition() = default;
-    DBCondition(const DBCondition&) = default;
-    DBCondition(DBCondition&& rv) : m_condition(std::move(rv.m_condition)) {}
+    DBCondition(const DBCondition &) = default;
+    DBCondition(DBCondition &&rv) : m_condition(std::move(rv.m_condition)) {}
 
-    explicit DBCondition(const char* cond) : m_condition(cond) {}
-    explicit DBCondition(const std::string& cond) : m_condition(cond) {}
+    explicit DBCondition(const char *cond) : m_condition(cond) {}
+    explicit DBCondition(const std::string &cond) : m_condition(cond) {}
 
-    DBCondition& operator=(const DBCondition&) = default;
-    DBCondition& operator=(DBCondition&& rv) {
+    DBCondition &operator=(const DBCondition &) = default;
+    DBCondition &operator=(DBCondition &&rv) {
         if (this != &rv) {
             m_condition = std::move(rv.m_condition);
         }
         return *this;
     }
 
-    DBCondition& operator&(const DBCondition& other);
-    DBCondition& operator|(const DBCondition& other);
+    DBCondition &operator&(const DBCondition &other);
+    DBCondition &operator|(const DBCondition &other);
 
     enum ORDERBY { ORDER_ASC, ORDER_DESC };
 
-    void orderBy(const std::string& field, ORDERBY order) {
+    void orderBy(const std::string &field, ORDERBY order) {
         m_condition = order == ORDERBY::ORDER_ASC
                         ? fmt::format("{} order by {} ASC", m_condition, field)
                         : fmt::format("{} order by {} DESC", m_condition, field);
     }
 
-    DBCondition& operator+(const ASC& asc) {
+    DBCondition &operator+(const ASC &asc) {
         orderBy(asc.name, ORDER_ASC);
         return *this;
     }
 
-    DBCondition& operator+(const DESC& desc) {
+    DBCondition &operator+(const DESC &desc) {
         orderBy(desc.name, ORDER_DESC);
         return *this;
     }
 
-    DBCondition& operator+(const LIMIT& limit) {
+    DBCondition &operator+(const LIMIT &limit) {
         m_condition = fmt::format("{} limit {}", m_condition, limit.limit);
         return *this;
     }
 
-    const std::string& str() const {
+    const std::string &str() const {
         return m_condition;
     }
 
@@ -90,27 +90,27 @@ private:
 };
 
 struct Field {
-    explicit Field(const char* name) : name(name) {}
-    explicit Field(const std::string& name) : name(name) {}
+    explicit Field(const char *name) : name(name) {}
+    explicit Field(const std::string &name) : name(name) {}
 
     // in 和 not_in 不支持 字符串，一般不会用到 in ("stra", "strb") 的 SQL 操作
     template <typename T>
-    DBCondition in(const std::vector<T>& vals) {
+    DBCondition in(const std::vector<T> &vals) {
         HKU_CHECK(!vals.empty(), "input vals can't be empty!");
         return DBCondition(fmt::format("({} in ({}))", name, fmt::join(vals, ",")));
     }
 
     template <typename T>
-    DBCondition not_in(const std::vector<T>& vals) {
+    DBCondition not_in(const std::vector<T> &vals) {
         HKU_CHECK(!vals.empty(), "input vals can't be empty!");
         return DBCondition(fmt::format("({} not in ({}))", name, fmt::join(vals, ",")));
     }
 
-    DBCondition like(const std::string& pattern) {
+    DBCondition like(const std::string &pattern) {
         return DBCondition(fmt::format(R"(({} like "{}"))", name, pattern));
     }
 
-    DBCondition like(const char* pattern) {
+    DBCondition like(const char *pattern) {
         return DBCondition(fmt::format(R"(({} like "{}"))", name, pattern));
     }
 
@@ -120,7 +120,7 @@ struct Field {
 // linux下类成员函数模板特化必须放在类外实现
 // 否则编译时会报：explicit specialization in non-namespace scope
 template <>
-inline DBCondition Field::in<std::string>(const std::vector<std::string>& vals) {
+inline DBCondition Field::in<std::string>(const std::vector<std::string> &vals) {
     HKU_CHECK(!vals.empty(), "input vals can't be empty!");
     std::ostringstream out;
     out << "(" << name << " in (";
@@ -133,7 +133,7 @@ inline DBCondition Field::in<std::string>(const std::vector<std::string>& vals)
 }
 
 template <>
-inline DBCondition Field::not_in<std::string>(const std::vector<std::string>& vals) {
+inline DBCondition Field::not_in<std::string>(const std::vector<std::string> &vals) {
     HKU_CHECK(!vals.empty(), "input vals can't be empty!");
     std::ostringstream out;
     out << "(" << name << " not in (";
@@ -145,103 +145,103 @@ inline DBCondition Field::not_in<std::string>(const std::vector<std::string>& va
     return DBCondition(out.str());
 }
 
-inline std::ostream& operator<<(std::ostream& out, const DBCondition& d) {
+inline std::ostream &operator<<(std::ostream &out, const DBCondition &d) {
     out << d.str();
     return out;
 }
 
 template <typename T>
-inline DBCondition operator==(const Field& field, T val) {
+inline DBCondition operator==(const Field &field, T val) {
     std::ostringstream out;
     out << "(" << field.name << "=" << val << ")";
     return DBCondition(out.str());
 }
 
 template <typename T>
-inline DBCondition operator!=(const Field& field, T val) {
+inline DBCondition operator!=(const Field &field, T val) {
     std::ostringstream out;
     out << "(" << field.name << "<>" << val << ")";
     return DBCondition(out.str());
 }
 
 template <typename T>
-inline DBCondition operator>(const Field& field, T val) {
+inline DBCondition operator>(const Field &field, T val) {
     std::ostringstream out;
     out << "(" << field.name << ">" << val << ")";
     return DBCondition(out.str());
 }
 
 template <typename T>
-inline DBCondition operator>=(const Field& field, T val) {
+inline DBCondition operator>=(const Field &field, T val) {
     std::ostringstream out;
     out << "(" << field.name << ">=" << val << ")";
     return DBCondition(out.str());
 }
 
 template <typename T>
-inline DBCondition operator<(const Field& field, T val) {
+inline DBCondition operator<(const Field &field, T val) {
     std::ostringstream out;
     out << "(" << field.name << "<" << val << ")";
     return DBCondition(out.str());
 }
 
 template <typename T>
-inline DBCondition operator<=(const Field& field, T val) {
+inline DBCondition operator<=(const Field &field, T val) {
     std::ostringstream out;
     out << "(" << field.name << "<=" << val << ")";
     return DBCondition(out.str());
 }
 
 template <>
-inline DBCondition operator!=(const Field& field, const char* val) {
+inline DBCondition operator!=(const Field &field, const char *val) {
     return DBCondition(fmt::format(R"(({}<>"{}"))", field.name, val));
 }
 
 template <>
-inline DBCondition operator>(const Field& field, const char* val) {
+inline DBCondition operator>(const Field &field, const char *val) {
     return DBCondition(fmt::format(R"(({}>"{}"))", field.name, val));
 }
 
 template <>
-inline DBCondition operator<(const Field& field, const char* val) {
+inline DBCondition operator<(const Field &field, const char *val) {
     return DBCondition(fmt::format(R"(({}<"{}"))", field.name, val));
 }
 
 template <>
-inline DBCondition operator>=(const Field& field, const char* val) {
+inline DBCondition operator>=(const Field &field, const char *val) {
     return DBCondition(fmt::format(R"(({}>="{}"))", field.name, val));
 }
 
 template <>
-inline DBCondition operator<=(const Field& field, const char* val) {
+inline DBCondition operator<=(const Field &field, const char *val) {
     return DBCondition(fmt::format(R"(({}<="{}"))", field.name, val));
 }
 
-inline DBCondition operator==(const Field& field, const std::string& val) {
+inline DBCondition operator==(const Field &field, const std::string &val) {
     return DBCondition(fmt::format(R"(({}="{}"))", field.name, val));
 }
 
-inline DBCondition operator!=(const Field& field, const std::string& val) {
+inline DBCondition operator!=(const Field &field, const std::string &val) {
     return DBCondition(fmt::format(R"(({}<>"{}"))", field.name, val));
 }
 
-inline DBCondition operator>(const Field& field, const std::string& val) {
+inline DBCondition operator>(const Field &field, const std::string &val) {
     return DBCondition(fmt::format(R"(({}>"{}"))", field.name, val));
 }
 
-inline DBCondition operator<(const Field& field, const std::string& val) {
+inline DBCondition operator<(const Field &field, const std::string &val) {
     return DBCondition(fmt::format(R"(({}<"{}"))", field.name, val));
 }
 
-inline DBCondition operator>=(const Field& field, const std::string& val) {
+inline DBCondition operator>=(const Field &field, const std::string &val) {
     return DBCondition(fmt::format(R"(({}>="{}"))", field.name, val));
 }
 
-inline DBCondition operator<=(const Field& field, const std::string& val) {
+inline DBCondition operator<=(const Field &field, const std::string &val) {
     return DBCondition(fmt::format(R"(({}<="{}"))", field.name, val));
 }
 
-inline DBCondition operator==(const Field& field, const char* val) {
+inline DBCondition operator==(const Field &field, const char *val) {
     return DBCondition(fmt::format(R"(({}="{}"))", field.name, val));
 }
 

hikyuu/include/hikyuu/utilities/db_connect/DBConnect.h

@@ -17,4 +17,14 @@
 #include "TableMacro.h"
 #include "DBUpgrade.h"
 
+#include "hikyuu/utilities/config.h"
+#if HKU_ENABLE_MYSQL
+#include "mysql/MySQLConnect.h"
+#endif
+
+#if HKU_ENABLE_SQLITE
+#include "sqlite/SQLiteConnect.h"
+#include "sqlite/SQLiteUtil.h"
+#endif
+
 #endif /* HIKYUU_DB_CONNECT_H */