hikyuu 2.2.2__py3-none-win_amd64.whl

hikyuu/include/hikyuu/data_driver/DriverConnectPool.h

@@ -0,0 +1,146 @@
+/*
+ *  Copyright(C) 2021 hikyuu.org
+ *
+ *  Create on: 2021-01-19
+ *     Author: fasiondog
+ */
+
+#pragma once
+
+#include <thread>
+#include <mutex>
+#include <queue>
+#include <memory>
+#include "../utilities/Parameter.h"
+
+namespace hku {
+
+/**
+ * 驱动资源池
+ * @tparam DriverConnectT 驱动类型，要求具备 DriverType *clone() 方法
+ * @ingroup DataDriver
+ */
+template <class DriverConnectT>
+class DriverConnectPool {
+public:
+    DriverConnectPool() = delete;
+    DriverConnectPool(const DriverConnectPool &) = delete;
+    DriverConnectPool &operator=(const DriverConnectPool &) = delete;
+
+    typedef typename DriverConnectT::DriverTypePtr DriverPtr;
+    typedef std::shared_ptr<DriverConnectT> DriverConnectPtr;
+
+    /**
+     * 构造函数
+     * @param prototype 驱动原型，所有权将被转移至该 pool
+     * @param maxConnect 允许的最大连接数，为 0 表示不限制
+     * @param maxIdleConnect 运行的最大空闲连接数，等于 0 时表示立刻释放，默认为CPU数
+     */
+    explicit DriverConnectPool(const DriverPtr &prototype, size_t maxConnect = 0,
+                               size_t maxIdleConnect = std::thread::hardware_concurrency())
+    : m_maxSize(maxConnect),
+      m_maxIdelSize(maxIdleConnect),
+      m_count(0),
+      m_prototype(prototype),
+      m_closer(this) {}
+
+    /**
+     * 析构函数，释放所有缓存的连接
+     */
+    virtual ~DriverConnectPool() {
+        while (!m_driverList.empty()) {
+            DriverConnectT *p = m_driverList.front();
+            m_driverList.pop();
+            if (p) {
+                delete p;
+            }
+        }
+    }
+
+    /** 获取可用连接，如超出允许的最大连接数，将阻塞等待，直到获得空闲资源 */
+    DriverConnectPtr getConnect() noexcept {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        if (m_driverList.empty()) {
+            if (m_maxSize > 0 && m_count >= m_maxSize) {
+                m_cond.wait(lock, [this] { return !m_driverList.empty(); });
+            } else {
+                m_count++;
+                return DriverConnectPtr(new DriverConnectT(m_prototype->clone()), m_closer);
+            }
+        }
+        DriverConnectT *p = m_driverList.front();
+        m_driverList.pop();
+        return DriverConnectPtr(p, m_closer);
+    }
+
+    DriverPtr getPrototype() {
+        return m_prototype;
+    }
+
+    /** 当前活动的连接数 */
+    size_t count() const {
+        return m_count;
+    }
+
+    /** 当前空闲的资源数 */
+    size_t idleCount() const {
+        return m_driverList.size();
+    }
+
+    /** 释放当前所有的空闲资源 */
+    void releaseIdleConnect() {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        while (!m_driverList.empty()) {
+            DriverConnectT *p = m_driverList.front();
+            m_driverList.pop();
+            m_count--;
+            if (p) {
+                delete p;
+            }
+        }
+    }
+
+private:
+    /** 归还至连接池 */
+    void returnDriver(DriverConnectT *p) {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        if (p) {
+            if (m_driverList.size() < m_maxIdelSize) {
+                m_driverList.push(p);
+                m_cond.notify_all();
+            } else {
+                delete p;
+                m_count--;
+            }
+        } else {
+            m_count--;
+            HKU_WARN("Trying to return an empty pointer!");
+        }
+    }
+
+private:
+    size_t m_maxSize;       //允许的最大连接数
+    size_t m_maxIdelSize;   //允许的最大空闲连接数
+    size_t m_count;         //当前活动的连接数
+    DriverPtr m_prototype;  // 驱动原型
+    std::mutex m_mutex;
+    std::condition_variable m_cond;
+    std::queue<DriverConnectT *> m_driverList;
+
+    class DriverCloser {
+    public:
+        explicit DriverCloser(DriverConnectPool *pool) : m_pool(pool) {}
+        void operator()(DriverConnectT *conn) {
+            if (m_pool && conn) {
+                m_pool->returnDriver(conn);
+            }
+        }
+
+    private:
+        DriverConnectPool *m_pool;
+    };
+
+    DriverCloser m_closer;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/data_driver/HistoryFinanceReader.h

@@ -0,0 +1,36 @@
+/*
+ * HistoryFinanceReader.h
+ *
+ * Copyright (c) 2019 fasiondog
+ *
+ *  Created on: 2019-4-2
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HISTORYFINANCEREADER_H_
+#define HISTORYFINANCEREADER_H_
+
+#include "../Stock.h"
+
+namespace hku {
+
+/**
+ * 读取历史财务信息
+ * @ingroup DataDriver
+ */
+class HKU_API HistoryFinanceReader {
+public:
+    HistoryFinanceReader() = delete;
+    explicit HistoryFinanceReader(const string& dir);
+    virtual ~HistoryFinanceReader();
+
+    PriceList getHistoryFinanceInfo(Datetime date, const string& market, const string& code);
+
+private:
+    string m_dir;  //历史财务信息文件存放目录
+};
+
+}  // namespace hku
+
+#endif /* HISTORYFINANCEREADER_H_ */

hikyuu/include/hikyuu/data_driver/KDataDriver.h

@@ -0,0 +1,194 @@
+/*
+ * KDataDriver.h
+ *
+ *  Created on: 2012-9-8
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef KDATADRIVER_H_
+#define KDATADRIVER_H_
+
+#include "../utilities/Parameter.h"
+#include "../KQuery.h"
+#include "../TimeLineRecord.h"
+#include "../TransRecord.h"
+
+namespace hku {
+
+/**
+ * K线数据驱动基类
+ * @ingroup DataDriver
+ */
+class HKU_API KDataDriver {
+    PARAMETER_SUPPORT
+
+public:
+    KDataDriver();
+
+    KDataDriver(const Parameter& params);
+
+    /**
+     * 构造函数
+     * @param name 驱动名称
+     */
+    KDataDriver(const string& name);
+    virtual ~KDataDriver() {}
+
+    /** 获取驱动名称 */
+    const string& name() const;
+
+    /** 驱动初始化 */
+    bool init(const Parameter&);
+
+    typedef shared_ptr<KDataDriver> KDataDriverPtr;
+    /**
+     * 克隆实现
+     */
+    KDataDriverPtr clone();
+
+    /**
+     * 子类克隆函数实现
+     */
+    virtual KDataDriverPtr _clone() = 0;
+
+    /**
+     * 子类初始化私有变量接口
+     * @return
+     */
+    virtual bool _init() {
+        return true;
+    }
+
+    /**
+     * 判断该引擎是否是位置索引方式查询速度更快，还是按日期方式查询更快
+     */
+    virtual bool isIndexFirst() = 0;
+
+    /**
+     * 是否支持并行数据加载
+     */
+    virtual bool canParallelLoad() = 0;
+
+    /**
+     * 获取指定类型的K线数据量
+     * @param market 市场简称
+     * @param code   证券代码
+     * @param kType  K线类型
+     * @return
+     */
+    virtual size_t getCount(const string& market, const string& code, const KQuery::KType& kType);
+
+    /**
+     * 获取指定日期范围对应的K线记录索引
+     * @param market 市场简称
+     * @param code   证券代码
+     * @param query  查询条件
+     * @param out_start [out] 对应K线记录位置
+     * @param out_end [out] 对应的K线记录位置
+     * @return
+     */
+    virtual bool getIndexRangeByDate(const string& market, const string& code, const KQuery& query,
+                                     size_t& out_start, size_t& out_end);
+
+    /**
+     * 获取 K 线数据
+     * @param market 市场简称
+     * @param code   证券代码
+     * @param query  查询条件
+     */
+    virtual KRecordList getKRecordList(const string& market, const string& code,
+                                       const KQuery& query);
+
+    /**
+     * 获取分时线
+     * @param market 市场简称
+     * @param code   证券代码
+     * @param query  查询条件
+     * @return
+     */
+    virtual TimeLineList getTimeLineList(const string& market, const string& code,
+                                         const KQuery& query);
+
+    /**
+     * 获取历史分笔数据
+     * @param market 市场简称
+     * @param code   证券代码
+     * @param query  查询条件
+     * @return
+     */
+    virtual TransList getTransList(const string& market, const string& code, const KQuery& query);
+
+private:
+    bool checkType();
+
+private:
+    string m_name;
+};
+
+typedef shared_ptr<KDataDriver> KDataDriverPtr;
+
+HKU_API std::ostream& operator<<(std::ostream&, const KDataDriver&);
+HKU_API std::ostream& operator<<(std::ostream&, const KDataDriverPtr&);
+
+inline const string& KDataDriver::name() const {
+    return m_name;
+}
+
+class KDataDriverConnect {
+public:
+    typedef KDataDriver DriverType;
+    typedef KDataDriverPtr DriverTypePtr;
+
+    explicit KDataDriverConnect(const KDataDriverPtr& driver) : m_driver(driver) {}
+    ~KDataDriverConnect() = default;
+
+    KDataDriverConnect(const KDataDriverConnect&) = delete;
+    KDataDriverConnect(KDataDriverConnect&&) = delete;
+    KDataDriverConnect& operator=(const KDataDriverConnect&) = delete;
+    KDataDriverConnect& operator=(KDataDriverConnect&&) = delete;
+
+    explicit operator bool() const noexcept {
+        return m_driver.get() != nullptr;
+    }
+
+    const string& name() const {
+        return m_driver->name();
+    }
+
+    bool isIndexFirst() {
+        return m_driver->isIndexFirst();
+    }
+
+    bool canParallelLoad() {
+        return m_driver->canParallelLoad();
+    }
+
+    size_t getCount(const string& market, const string& code, KQuery::KType kType) {
+        return m_driver->getCount(market, code, kType);
+    }
+
+    bool getIndexRangeByDate(const string& market, const string& code, const KQuery& query,
+                             size_t& out_start, size_t& out_end) {
+        return m_driver->getIndexRangeByDate(market, code, query, out_start, out_end);
+    }
+
+    KRecordList getKRecordList(const string& market, const string& code, const KQuery& query) {
+        return m_driver->getKRecordList(market, code, query);
+    }
+
+    TimeLineList getTimeLineList(const string& market, const string& code, const KQuery& query) {
+        return m_driver->getTimeLineList(market, code, query);
+    }
+
+    TransList getTransList(const string& market, const string& code, const KQuery& query) {
+        return m_driver->getTransList(market, code, query);
+    }
+
+private:
+    KDataDriverPtr m_driver;
+};
+
+}  // namespace hku
+
+#endif /* KDATADRIVER_H_ */

hikyuu/include/hikyuu/data_driver/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/data_driver/base_info/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/data_driver/base_info/mysql/MySQLBaseInfoDriver.h

@@ -0,0 +1,54 @@
+/*
+ * MySQLBaseInfoDriver.h
+ *
+ *  Created on: 2014年8月27日
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef MYSQLBASEINFODRIVER_H_
+#define MYSQLBASEINFODRIVER_H_
+
+#include "../../../utilities/ConnectPool.h"
+#include "../../../utilities/db_connect/mysql/MySQLConnect.h"
+#include "../../BaseInfoDriver.h"
+
+#if defined(_MSC_VER)
+#include <mysql.h>
+#else
+#include <mysql/mysql.h>
+#endif
+
+namespace hku {
+
+class MySQLBaseInfoDriver : public BaseInfoDriver {
+public:
+    MySQLBaseInfoDriver();
+    virtual ~MySQLBaseInfoDriver();
+
+    virtual bool _init() override;
+    virtual vector<StockInfo> getAllStockInfo() override;
+    virtual vector<MarketInfo> getAllMarketInfo() override;
+    virtual vector<StockTypeInfo> getAllStockTypeInfo() override;
+
+    virtual Parameter getFinanceInfo(const string& market, const string& code) override;
+    virtual StockWeightList getStockWeightList(const string& market, const string& code,
+                                               Datetime start, Datetime end) override;
+    virtual unordered_map<string, StockWeightList> getAllStockWeightList() override;
+    virtual MarketInfo getMarketInfo(const string& market) override;
+    virtual StockTypeInfo getStockTypeInfo(uint32_t type) override;
+    virtual StockInfo getStockInfo(string market, const string& code) override;
+    virtual std::unordered_set<Datetime> getAllHolidays() override;
+    virtual ZhBond10List getAllZhBond10() override;
+
+    virtual vector<std::pair<size_t, string>> getHistoryFinanceField() override;
+    virtual vector<HistoryFinanceInfo> getHistoryFinance(const string& market, const string& code,
+                                                         Datetime start, Datetime end) override;
+
+private:
+    ConnectPool<MySQLConnect>* m_pool;
+};
+
+} /* namespace hku */
+
+#endif /* MYSQLBASEINFODRIVER_H_ */

hikyuu/include/hikyuu/data_driver/base_info/mysql/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/data_driver/base_info/sqlite/SQLiteBaseInfoDriver.h

@@ -0,0 +1,50 @@
+/*
+ * SQLiteBaseInfoDriver.h
+ *
+ *  Copyright (c) 2019 fasiondog
+ *
+ *  Created on: 2019-8-11
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIKYUU_DATA_DRIVER_BASE_INFO_SQLITE_SQLITEBASEINFODRIVER_H
+#define HIKYUU_DATA_DRIVER_BASE_INFO_SQLITE_SQLITEBASEINFODRIVER_H
+
+#include "../../../utilities/db_connect/sqlite/SQLiteConnect.h"
+#include "../../../utilities/ConnectPool.h"
+#include "../../BaseInfoDriver.h"
+
+namespace hku {
+
+class SQLiteBaseInfoDriver : public BaseInfoDriver {
+public:
+    SQLiteBaseInfoDriver();
+    virtual ~SQLiteBaseInfoDriver();
+
+    virtual bool _init() override;
+    virtual vector<MarketInfo> getAllMarketInfo() override;
+    virtual vector<StockTypeInfo> getAllStockTypeInfo() override;
+
+    virtual Parameter getFinanceInfo(const string& market, const string& code) override;
+    virtual StockWeightList getStockWeightList(const string& market, const string& code,
+                                               Datetime start, Datetime end) override;
+    virtual unordered_map<string, StockWeightList> getAllStockWeightList() override;
+    virtual MarketInfo getMarketInfo(const string& market) override;
+    virtual StockTypeInfo getStockTypeInfo(uint32_t type) override;
+    virtual StockInfo getStockInfo(string market, const string& code) override;
+    virtual vector<StockInfo> getAllStockInfo() override;
+    virtual std::unordered_set<Datetime> getAllHolidays() override;
+    virtual ZhBond10List getAllZhBond10() override;
+
+    virtual vector<std::pair<size_t, string>> getHistoryFinanceField() override;
+    virtual vector<HistoryFinanceInfo> getHistoryFinance(const string& market, const string& code,
+                                                         Datetime start, Datetime end) override;
+
+private:
+    // 股票基本信息数据库实例
+    ConnectPool<SQLiteConnect>* m_pool;
+};
+
+} /* namespace hku */
+#endif /* HIKYUU_DATA_DRIVER_BASE_INFO_SQLITE_SQLITEBASEINFODRIVER_H */

hikyuu/include/hikyuu/data_driver/base_info/sqlite/__init__.py

@@ -0,0 +1 @@
+

hikyuu/include/hikyuu/data_driver/base_info/table/HistoryFinanceFieldTable.h

@@ -0,0 +1,19 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-04-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/utilities/db_connect/TableMacro.h"
+
+namespace hku {
+
+struct HistoryFinanceFieldTable {
+    TABLE_BIND1(HistoryFinanceFieldTable, HistoryFinanceField, name)
+    std::string name;
+};
+
+}

hikyuu/include/hikyuu/data_driver/base_info/table/HistoryFinanceTable.h

@@ -0,0 +1,23 @@
+/*
+ *  Copyright (c) 2024 hikyuu.org
+ *
+ *  Created on: 2024-04-13
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/utilities/db_connect/TableMacro.h"
+
+namespace hku {
+
+struct HistoryFinanceTable {
+    TABLE_BIND4(HistoryFinanceTable, HistoryFinance, file_date, report_date, market_code, values)
+    uint64_t file_date{0};
+    uint64_t report_date{0};
+    std::string market_code;
+    // std::vector<float> values;
+    std::vector<char> values;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/data_driver/base_info/table/HolidayTable.h

@@ -0,0 +1,29 @@
+/*
+ *  Copyright(C) 2021 hikyuu.org
+ *
+ *  Create on: 2021-02-06
+ *     Author: fasiondog
+ */
+
+#pragma once
+
+#include <limits>
+#include "../../../utilities/db_connect/SQLStatementBase.h"
+#include "../../../utilities/db_connect/TableMacro.h"
+
+namespace hku {
+
+class HolidayTable {
+    TABLE_BIND1(HolidayTable, holiday, date)
+
+public:
+    Datetime datetime() const {
+        HKU_CHECK(date <= 99999999, "Invalid holiday date: {}!", date);
+        return Datetime(date * 10000LL);
+    }
+
+private:
+    uint64_t date{Datetime().number()};
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/data_driver/base_info/table/MarketInfoTable.h

@@ -0,0 +1,127 @@
+/*
+ * MarketInfoTable.h
+ *
+ *  Copyright (c) 2019 fasiondog
+ *
+ *  Created on: 2019-8-11
+ *      Author: fasiondog
+ */
+
+#pragma once
+#ifndef HIKYUU_DATA_DRIVER_BASE_INFO_TABLE_MARKETINFOTABLE_H
+#define HIKYUU_DATA_DRIVER_BASE_INFO_TABLE_MARKETINFOTABLE_H
+
+#include "../../../utilities/db_connect/SQLStatementBase.h"
+
+namespace hku {
+
+class MarketInfoTable {
+public:
+    MarketInfoTable()
+    : m_marketid(0),
+      m_lastDate(0),
+      m_openTime1(0),
+      m_closeTime1(0),
+      m_openTime2(0),
+      m_closeTime2(0) {}
+
+    uint64_t id() const {
+        return m_marketid;
+    }
+
+    const string& market() const {
+        return m_market;
+    }
+
+    const string& name() const {
+        return m_name;
+    }
+
+    const string& description() const {
+        return m_description;
+    }
+
+    const string& code() const {
+        return m_code;
+    }
+
+    Datetime lastDate() const {
+        HKU_CHECK(m_lastDate <= 99999999, "Invalid lastDate: {}!", m_lastDate);
+        return Datetime(m_lastDate * 10000LL);
+    }
+
+    TimeDelta openTime1() const {
+        return _transTimeDelta(m_openTime1);
+    }
+
+    TimeDelta closeTime1() const {
+        return _transTimeDelta(m_closeTime1);
+    }
+
+    TimeDelta openTime2() const {
+        return _transTimeDelta(m_openTime2);
+    }
+
+    TimeDelta closeTime2() const {
+        return _transTimeDelta(m_closeTime2);
+    }
+
+private:
+    TimeDelta _transTimeDelta(uint64_t time) const {
+        int64_t hours = time / 100;
+        HKU_CHECK(hours >= 0 && hours <= 23, "Invalid time: {}!", time);
+        int64_t mins = time - hours * 100;
+        HKU_CHECK(mins >= 0 && mins <= 59, "Invalid time: {}!", time);
+        return TimeDelta(0, hours, mins);
+    }
+
+public:
+    static const char* getInsertSQL() {
+        return "insert into `market` "
+               "(`marketid`, `market`, `name`, `description`, `code`, `lastDate`,"
+               " `openTime1`, `closeTime1`, `openTime2`, `closeTime2`) "
+               "values (?,?,?,?,?,?,?,?,?,?)";
+    }
+
+    static const char* getUpdateSQL() {
+        return "update `market` set `market`=?, `name`=?, `description`=?, "
+               "`code`=?, `lastDate`=?, `openTime1`=?, `closeTime1`=?, "
+               "`openTime2=`=?, `closeTime2`=? where `marketid`=?";
+    }
+
+    static const char* getSelectSQL() {
+        return "select `marketid`,`market`,`name`, `description`, `code`, `lastDate`, "
+               "`openTime1`, `closeTime1`, `openTime2`, `closeTime2` from `market`";
+    }
+
+    void save(const SQLStatementPtr& st) const {
+        st->bind(0, m_marketid, m_market, m_name, m_description, m_code, m_lastDate, m_openTime1,
+                 m_closeTime1, m_openTime2, m_closeTime2);
+    }
+
+    void update(const SQLStatementPtr& st) const {
+        st->bind(0, m_market, m_name, m_description, m_code, m_lastDate, m_openTime1, m_closeTime1,
+                 m_openTime2, m_closeTime2, m_marketid);
+    }
+
+    void load(const SQLStatementPtr& st) {
+        st->getColumn(0, m_marketid, m_market, m_name, m_description, m_code, m_lastDate,
+                      m_openTime1, m_closeTime1, m_openTime2, m_closeTime2);
+    }
+
+private:
+    uint64_t m_marketid;
+    string m_market;
+    string m_name;
+    string m_description;
+    string m_code;
+    uint64_t m_lastDate;
+    uint64_t m_openTime1;
+    uint64_t m_closeTime1;
+    uint64_t m_openTime2;
+    uint64_t m_closeTime2;
+};
+
+}  // namespace hku
+
+#endif /* HIKYUU_DATA_DRIVER_BASE_INFO_TABLE_MARKETINFOTABLE_H */