hikyuu 2.1.0__cp38-none-win_amd64.whl → 2.1.1__cp38-none-win_amd64.whl

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 */

hikyuu/include/hikyuu/utilities/db_connect/DBConnectBase.h

@@ -10,8 +10,8 @@
 #ifndef HIKYUU_DB_CONNECT_DBCONNECTBASE_H
 #define HIKYUU_DB_CONNECT_DBCONNECTBASE_H
 
-#include "../../DataType.h"
 #include "../../utilities/Parameter.h"
+#include "../Null.h"
 #include "DBCondition.h"
 #include "SQLStatementBase.h"
 #include "SQLException.h"
@@ -25,7 +25,7 @@ class SQLResultSet;
  * 数据库连接基类
  * @ingroup DBConnect
  */
-class HKU_API DBConnectBase : public std::enable_shared_from_this<DBConnectBase> {
+class HKU_UTILS_API DBConnectBase : public std::enable_shared_from_this<DBConnectBase> {
     PARAMETER_SUPPORT  // NOSONAR
 
       public :
@@ -297,7 +297,7 @@ private:
 };
 
 /** @ingroup DBConnect */
-typedef shared_ptr<DBConnectBase> DBConnectPtr;
+typedef std::shared_ptr<DBConnectBase> DBConnectPtr;
 
 //-------------------------------------------------------------------------
 // inline方法实现
@@ -366,19 +366,16 @@ void DBConnectBase::save(T &item, bool autotrans) {
         if (autotrans) {
             commit();
         }
-
     } catch (hku::SQLException &e) {
         if (autotrans) {
             rollback();
         }
         SQL_THROW(e.errcode(), "failed save! sql: {}! {}", st->getSqlString(), e.what());
-
     } catch (std::exception &e) {
         if (autotrans) {
             rollback();
         }
         HKU_THROW("failed save! sql: {}! {}", st->getSqlString(), e.what());
-
     } catch (...) {
         if (autotrans) {
             rollback();
@@ -409,19 +406,16 @@ void DBConnectBase::batchSave(InputIterator first, InputIterator last, bool auto
         if (autotrans) {
             commit();
         }
-
     } catch (hku::SQLException &e) {
         if (autotrans) {
             rollback();
         }
         SQL_THROW(e.errcode(), "failed batch save! sql: {}! {}", st->getSqlString(), e.what());
-
     } catch (std::exception &e) {
         if (autotrans) {
             rollback();
         }
         HKU_THROW("failed batch save! sql: {}! {}", st->getSqlString(), e.what());
-
     } catch (...) {
         if (autotrans) {
             rollback();
@@ -431,7 +425,7 @@ void DBConnectBase::batchSave(InputIterator first, InputIterator last, bool auto
 }
 
 template <typename T>
-void DBConnectBase::load(T &item, const string &where) {
+void DBConnectBase::load(T &item, const std::string &where) {
     std::ostringstream sql;
     if (where != "") {
         sql << T::getSelectSQL() << " where " << where << " limit 1";
@@ -451,7 +445,7 @@ void DBConnectBase::load(T &item, const DBCondition &cond) {
 }
 
 template <typename Container>
-void DBConnectBase::batchLoad(Container &container, const string &where) {
+void DBConnectBase::batchLoad(Container &container, const std::string &where) {
     std::ostringstream sql;
     if (where != "") {
         sql << Container::value_type::getSelectSQL() << " where " << where;
@@ -513,19 +507,16 @@ void DBConnectBase::batchUpdate(InputIterator first, InputIterator last, bool au
         if (autotrans) {
             commit();
         }
-
     } catch (hku::SQLException &e) {
         if (autotrans) {
             rollback();
         }
         SQL_THROW(e.errcode(), "failed batch save! sql: {}! {}", st->getSqlString(), e.what());
-
     } catch (std::exception &e) {
         if (autotrans) {
             rollback();
         }
         HKU_THROW("failed batch update! sql: {}! {}", st->getSqlString(), e.what());
-
     } catch (...) {
         if (autotrans) {
             rollback();
@@ -570,19 +561,16 @@ void DBConnectBase::remove(T &item, bool autotrans) {
             commit();
         }
         item.rowid(0);
-
     } catch (hku::SQLException &e) {
         if (autotrans) {
             rollback();
         }
         SQL_THROW(e.errcode(), "failed delete! sql: {}! {}", st->getSqlString(), e.what());
-
     } catch (std::exception &e) {
         if (autotrans) {
             rollback();
         }
         HKU_THROW("failed delete! sql: {}! {}", st->getSqlString(), e.what());
-
     } catch (...) {
         if (autotrans) {
             rollback();
@@ -610,19 +598,16 @@ void DBConnectBase::batchRemove(InputIterator first, InputIterator last, bool au
         if (autotrans) {
             commit();
         }
-
     } catch (hku::SQLException &e) {
         if (autotrans) {
             rollback();
         }
         SQL_THROW(e.errcode(), "failed batch delete! {}", e.what());
-
     } catch (std::exception &e) {
         if (autotrans) {
             rollback();
         }
         HKU_THROW("failed batch delete! {}", e.what());
-
     } catch (...) {
         if (autotrans) {
             rollback();
@@ -645,13 +630,11 @@ inline void DBConnectBase::remove(const std::string &tablename, const std::strin
         if (autotrans) {
             commit();
         }
-
     } catch (hku::SQLException &e) {
         if (autotrans) {
             rollback();
         }
         SQL_THROW(e.errcode(), "Failed exec sql: {}! {}", sql, e.what());
-
     } catch (std::exception &e) {
         if (autotrans) {
             rollback();

hikyuu/include/hikyuu/utilities/db_connect/DBUpgrade.h

@@ -21,8 +21,8 @@ namespace hku {
  * @param create_script 数据库创建脚本，若对应的数据库不存在则使用该脚本创建数据库
  * @ingroup DataDriver
  */
-void HKU_API DBUpgrade(const DBConnectPtr &driver, const char *module_name,
-                            const std::vector<std::string> &upgrade_scripts, int start_version = 2,
-                       const char *create_script = nullptr);
+void HKU_UTILS_API DBUpgrade(const DBConnectPtr &driver, const char *module_name,
+                             const std::vector<std::string> &upgrade_scripts, int start_version = 2,
+                             const char *create_script = nullptr);
 
 }  // namespace hku

hikyuu/include/hikyuu/utilities/db_connect/SQLException.h

@@ -8,7 +8,7 @@
 #pragma once
 
 #include <fmt/format.h>
-#include "hikyuu/exception.h"
+#include "hikyuu/utilities/exception.h"
 
 namespace hku {
 

hikyuu/include/hikyuu/utilities/db_connect/SQLResultSet.h

@@ -9,7 +9,7 @@
 
 #include <iterator>
 #include "hikyuu/utilities/arithmetic.h"
-#include "hikyuu/Log.h"
+#include "hikyuu/utilities/Log.h"
 #include "hikyuu/utilities/osdef.h"
 #include "DBConnectBase.h"
 

hikyuu/include/hikyuu/utilities/db_connect/SQLStatementBase.h

@@ -21,7 +21,7 @@ namespace hku {
 class DBConnectBase;
 
 /** @ingroup DBConnect */
-typedef shared_ptr<DBConnectBase> DBConnectPtr;
+typedef std::shared_ptr<DBConnectBase> DBConnectPtr;
 
 /** @ingroup DBConnect */
 class null_blob_exception : public exception {
@@ -34,19 +34,19 @@ public:
  * SQL Statement 基类
  * @ingroup DBConnect
  */
-class HKU_API SQLStatementBase {
+class HKU_UTILS_API SQLStatementBase {
 public:
     /**
      * 构造函数
      * @param driver 数据库连接
      * @param sql_statement SQL语句
      */
-    SQLStatementBase(DBConnectBase *driver, const string &sql_statement);
+    SQLStatementBase(DBConnectBase *driver, const std::string &sql_statement);
 
     virtual ~SQLStatementBase() = default;
 
     /** 获取构建时传入的表达式SQL语句 */
-    const string &getSqlString() const;
+    const std::string &getSqlString() const;
 
     /** 获取数据驱动 */
     DBConnectBase *getConnect() const;
@@ -163,7 +163,7 @@ protected:
 };
 
 /** @ingroup DBConnect */
-typedef shared_ptr<SQLStatementBase> SQLStatementPtr;
+typedef std::shared_ptr<SQLStatementBase> SQLStatementPtr;
 
 inline SQLStatementBase ::SQLStatementBase(DBConnectBase *driver, const std::string &sql_statement)
 : m_driver(driver), m_sql_string(sql_statement) {
@@ -183,7 +183,7 @@ inline void SQLStatementBase::bind(int idx, float item) {
 }
 
 inline void SQLStatementBase::exec() {
-#ifdef HKU_SQL_TRACE
+#if HKU_SQL_TRACE
     HKU_DEBUG(m_sql_string);
 #endif
     sub_exec();
@@ -277,7 +277,7 @@ inline void SQLStatementBase::getColumn(int idx, std::vector<char> &item) {
 template <typename T>
 typename std::enable_if<!std::numeric_limits<T>::is_integer>::type SQLStatementBase::getColumn(
   int idx, T &item) {
-    string tmp;
+    std::string tmp;
     try {
         sub_getColumnAsBlob(idx, tmp);
     } catch (null_blob_exception &) {

hikyuu/include/hikyuu/utilities/db_connect/TableMacro.h

@@ -2168,8 +2168,7 @@ public:
     }
 
 #define TABLE_NO_AUTOID_BIND12(ROWID, table, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12)    \
-    pprivate:                                                                                      \
-    uint64_t m_rowid = 0;                                                                          \
+    pprivate : uint64_t m_rowid = 0;                                                               \
                                                                                                    \
 public:                                                                                            \
     bool valid() const {                                                                           \