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

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 {                                                                           \

hikyuu/include/hikyuu/utilities/db_connect/mysql/MySQLConnect.h

@@ -22,20 +22,20 @@
 
 namespace hku {
 
-class HKU_API MySQLConnect : public DBConnectBase {
+class HKU_UTILS_API MySQLConnect : public DBConnectBase {
 public:
-    explicit MySQLConnect(const Parameter& param);
+    explicit MySQLConnect(const Parameter &param);
     virtual ~MySQLConnect();
 
-    MySQLConnect(const MySQLConnect&) = delete;
-    MySQLConnect& operator=(const MySQLConnect&) = delete;
+    MySQLConnect(const MySQLConnect &) = delete;
+    MySQLConnect &operator=(const MySQLConnect &) = delete;
 
     virtual bool ping() override;
 
-    virtual int64_t exec(const std::string& sql_string) override;
-    virtual SQLStatementPtr getStatement(const std::string& sql_statement) override;
-    virtual bool tableExist(const std::string& tablename) override;
-    virtual void resetAutoIncrement(const std::string& tablename) override;
+    virtual int64_t exec(const std::string &sql_string) override;
+    virtual SQLStatementPtr getStatement(const std::string &sql_statement) override;
+    virtual bool tableExist(const std::string &tablename) override;
+    virtual void resetAutoIncrement(const std::string &tablename) override;
 
     virtual void transaction() noexcept override;
     virtual void commit() noexcept override;
@@ -48,7 +48,7 @@ private:
 
 private:
     friend class MySQLStatement;
-    MYSQL* m_mysql;
+    MYSQL *m_mysql;
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/utilities/db_connect/mysql/MySQLStatement.h

@@ -26,16 +26,16 @@
 typedef bool my_bool;
 #endif
 
-#ifndef HKU_API
-#define HKU_API
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
 #endif
 
 namespace hku {
 
-class HKU_API MySQLStatement : public SQLStatementBase {
+class HKU_UTILS_API MySQLStatement : public SQLStatementBase {
 public:
     MySQLStatement() = delete;
-    MySQLStatement(DBConnectBase* driver, const std::string& sql_statement);
+    MySQLStatement(DBConnectBase *driver, const std::string &sql_statement);
     virtual ~MySQLStatement();
 
     virtual void sub_exec() override;
@@ -45,28 +45,28 @@ public:
     virtual void sub_bindNull(int idx) override;
     virtual void sub_bindInt(int idx, int64_t value) override;
     virtual void sub_bindDouble(int idx, double item) override;
-    virtual void sub_bindDatetime(int idx, const Datetime& item) override;
-    virtual void sub_bindText(int idx, const std::string& item) override;
-    virtual void sub_bindText(int idx, const char* item, size_t len) override;
-    virtual void sub_bindBlob(int idx, const std::string& item) override;
-    virtual void sub_bindBlob(int idx, const std::vector<char>& item) override;
+    virtual void sub_bindDatetime(int idx, const Datetime &item) override;
+    virtual void sub_bindText(int idx, const std::string &item) override;
+    virtual void sub_bindText(int idx, const char *item, size_t len) override;
+    virtual void sub_bindBlob(int idx, const std::string &item) override;
+    virtual void sub_bindBlob(int idx, const std::vector<char> &item) override;
 
     virtual int sub_getNumColumns() const override;
-    virtual void sub_getColumnAsInt64(int idx, int64_t& item) override;
-    virtual void sub_getColumnAsDouble(int idx, double& item) override;
-    virtual void sub_getColumnAsDatetime(int idx, Datetime& item) override;
-    virtual void sub_getColumnAsText(int idx, std::string& item) override;
-    virtual void sub_getColumnAsBlob(int idx, std::string& item) override;
-    virtual void sub_getColumnAsBlob(int idx, std::vector<char>& item) override;
+    virtual void sub_getColumnAsInt64(int idx, int64_t &item) override;
+    virtual void sub_getColumnAsDouble(int idx, double &item) override;
+    virtual void sub_getColumnAsDatetime(int idx, Datetime &item) override;
+    virtual void sub_getColumnAsText(int idx, std::string &item) override;
+    virtual void sub_getColumnAsBlob(int idx, std::string &item) override;
+    virtual void sub_getColumnAsBlob(int idx, std::vector<char> &item) override;
 
 private:
     void _reset();
     void _bindResult();
 
 private:
-    MYSQL* m_db;
-    MYSQL_STMT* m_stmt;
-    MYSQL_RES* m_meta_result;
+    MYSQL *m_db;
+    MYSQL_STMT *m_stmt;
+    MYSQL_RES *m_meta_result;
     bool m_needs_reset;
     bool m_has_bind_result;
     std::vector<MYSQL_BIND> m_param_bind;

hikyuu/include/hikyuu/utilities/db_connect/sqlite/SQLiteConnect.h

@@ -25,7 +25,7 @@ namespace hku {
  * SQLite连接
  * @ingroup SQLite
  */
-class HKU_API SQLiteConnect : public DBConnectBase {
+class HKU_UTILS_API SQLiteConnect : public DBConnectBase {
 public:
     /**
      * 构造函数
@@ -78,11 +78,11 @@ private:
 
 private:
     friend class SQLiteStatement;
-    string m_dbname;
+    std::string m_dbname;
     sqlite3 *m_db;
 };
 
-typedef shared_ptr<SQLiteConnect> SQLiteConnectPtr;
+typedef std::shared_ptr<SQLiteConnect> SQLiteConnectPtr;
 
 }  // namespace hku
 

hikyuu/include/hikyuu/utilities/db_connect/sqlite/SQLiteStatement.h

@@ -19,7 +19,7 @@ namespace hku {
  * SQLite Statemen
  * @ingroup DBConnect
  */
-class HKU_API SQLiteStatement : public SQLStatementBase {
+class HKU_UTILS_API SQLiteStatement : public SQLStatementBase {
 public:
     SQLiteStatement() = delete;
 
@@ -28,7 +28,7 @@ public:
      * @param driver 数据库连接
      * @param sql_statement SQL语句
      */
-    SQLiteStatement(DBConnectBase *driver, const string &sql_statement);
+    SQLiteStatement(DBConnectBase *driver, const std::string &sql_statement);
 
     /** 析构函数 */
     virtual ~SQLiteStatement();

hikyuu/include/hikyuu/utilities/db_connect/sqlite/SQLiteUtil.h

@@ -15,7 +15,7 @@ namespace hku {
  * @brief SQLite 其他相关操作方法集合
  * @ingroup DBConnect
  */
-class HKU_API SQLiteUtil {
+class HKU_UTILS_API SQLiteUtil {
 public:
     SQLiteUtil() = default;
     ~SQLiteUtil() = default;
@@ -43,8 +43,8 @@ public:
      * @param n_page 分批备份时每次循环备份的 page 数，小于等于0时，一次性备份，不进行分批备份
      * @param step_sleep 分批备份时每次循环后，休眠间隔时长（毫秒），以便让出cpu
      */
-    static BackupResult onlineBackup(const std::shared_ptr<SQLiteConnect>& conn,
-                                     const std::string& dst, int n_page = -1,
+    static BackupResult onlineBackup(const std::shared_ptr<SQLiteConnect> &conn,
+                                     const std::string &dst, int n_page = -1,
                                      int step_sleep = 250) noexcept;
     /**
      * @brief 在线备份数据库，不影响其他数据库连接进行操作
@@ -53,7 +53,7 @@ public:
      * @param n_page 分批备份时每次循环备份的 page 数，小于等于0时，一次性备份，不进行分批备份
      * @param step_sleep 分批备份时每次循环后，休眠间隔时长（毫秒），以便让出cpu
      */
-    static BackupResult onlineBackup(const std::string& src, const std::string& dst,
+    static BackupResult onlineBackup(const std::string &src, const std::string &dst,
                                      int n_page = -1, int step_sleep = 250) noexcept;
 
     /**
@@ -65,7 +65,7 @@ public:
      * @param save_bad 是否保存损坏的数据，将 dst 及 dst-journal 加上后缀 .bad 另存
      * @return RecoverResult
      */
-    static RecoverResult recoverFromBackup(const std::string& backup, const std::string& dst,
+    static RecoverResult recoverFromBackup(const std::string &backup, const std::string &dst,
                                            bool save_bad = false) noexcept;
 
     /**
@@ -74,7 +74,7 @@ public:
      * @return true 指定的数据库文件及其日志文件都被成功删除或都不存在时，返回成功
      * @return false 指定的数据文件及其日志文件，其中一个删除失败都会返回删除失败
      */
-    static bool removeDBFile(const std::string& dbfilename);
+    static bool removeDBFile(const std::string &dbfilename);
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/{exception.h → utilities/exception.h}

@@ -14,39 +14,38 @@
 #include <string>
 #include <exception>
 
+#ifndef HKU_UTILS_API
+#define HKU_UTILS_API
+#endif
+
 namespace hku {
 
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4275)
+#endif
+
 /**
  * @ingroup Utilities
  * @addtogroup Exception Exception 异常处理
  * @{
  */
 
-#if !defined(__clang__) && !defined(__GNUC__)
-class exception : public std::exception {
-public:
-    exception() : std::exception("Unknown exception!") {}
-    exception(const std::string& msg)  // cppcheck-suppress noExplicitConstructor
-    : std::exception(msg.c_str()) {}
-    exception(const char* msg) : std::exception(msg) {}  // cppcheck-suppress noExplicitConstructor
-};
-
-#else
-// llvm 中的 std::exception 不接受参数
-class exception : public std::exception {
+class HKU_UTILS_API exception : public std::exception {
 public:
     exception() : m_msg("Unknown exception!") {}
     exception(const char *msg) : m_msg(msg) {}         // cppcheck-suppress noExplicitConstructor
     exception(const std::string &msg) : m_msg(msg) {}  // cppcheck-suppress noExplicitConstructor
     virtual ~exception() noexcept {}
-    virtual const char *what() const noexcept {
-        return m_msg.c_str();
-    }
+    virtual const char *what() const noexcept;
 
 protected:
     std::string m_msg;
 };
-#endif /* #ifdef __clang__ */
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
 
 } /* namespace hku */