hikyuu 2.7.0__py3-none-manylinux2014_aarch64.whl → 2.7.5__py3-none-manylinux2014_aarch64.whl

hikyuu/include/hikyuu/indicator_talib/imp/ta_imp.h

@@ -113,7 +113,7 @@
                                                                                            \
     void Cls_##func::_dyn_run_one_step(const Indicator &ind, size_t curPos, size_t step) { \
         int back = func_lookback(step);                                                    \
-        HKU_IF_RETURN(back<0 || back + ind.discard()> curPos, void());                     \
+        HKU_IF_RETURN(back < 0 || back + ind.discard() > curPos, void());                  \
                                                                                            \
         std::unique_ptr<double[]> buf = std::make_unique<double[]>(curPos);                \
         auto const *src = ind.data();                                                      \
@@ -181,7 +181,7 @@
                                                                                            \
     void Cls_##func::_dyn_run_one_step(const Indicator &ind, size_t curPos, size_t step) { \
         int back = func_lookback(step);                                                    \
-        HKU_IF_RETURN(back<0 || back + ind.discard()> curPos, void());                     \
+        HKU_IF_RETURN(back < 0 || back + ind.discard() > curPos, void());                  \
                                                                                            \
         std::unique_ptr<int[]> buf = std::make_unique<int[]>(curPos);                      \
         auto const *src = ind.data();                                                      \
@@ -283,7 +283,7 @@
                                                                                            \
     void Cls_##func::_dyn_run_one_step(const Indicator &ind, size_t curPos, size_t step) { \
         int back = func_lookback(step);                                                    \
-        HKU_IF_RETURN(back<0 || back + ind.discard()> curPos, void());                     \
+        HKU_IF_RETURN(back < 0 || back + ind.discard() > curPos, void());                  \
                                                                                            \
         std::unique_ptr<int[]> buf = std::make_unique<int[]>(2 * curPos);                  \
         int *buf0 = buf.get();                                                             \
@@ -350,7 +350,7 @@
                                                                                            \
     void Cls_##func::_dyn_run_one_step(const Indicator &ind, size_t curPos, size_t step) { \
         int back = func_lookback(step);                                                    \
-        HKU_IF_RETURN(back<0 || back + ind.discard()> curPos, void());                     \
+        HKU_IF_RETURN(back < 0 || back + ind.discard() > curPos, void());                  \
                                                                                            \
         std::unique_ptr<double[]> buf = std::make_unique<double[]>(2 * curPos);            \
         double *dst0 = buf.get();                                                          \
@@ -418,7 +418,7 @@
                                                                                            \
     void Cls_##func::_dyn_run_one_step(const Indicator &ind, size_t curPos, size_t step) { \
         int back = func_lookback(step);                                                    \
-        HKU_IF_RETURN(back<0 || back + ind.discard()> curPos, void());                     \
+        HKU_IF_RETURN(back < 0 || back + ind.discard() > curPos, void());                  \
                                                                                            \
         std::unique_ptr<double[]> buf = std::make_unique<double[]>(3 * curPos);            \
         double *dst0 = buf.get();                                                          \
@@ -558,11 +558,8 @@
     }
 
 #define TA_OHLC_OUT1_IMP(func, func_lookback)                                           \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                \
-                                                                                        \
-    Cls_##func::Cls_##func(const KData &k) : IndicatorImp(#func, 1) {                   \
-        setParam<KData>("kdata", k);                                                    \
-        Cls_##func::_calculate(Indicator());                                            \
+    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                 \
+        m_need_context = true;                                                          \
     }                                                                                   \
                                                                                         \
     void Cls_##func::_calculate(const Indicator &data) {                                \
@@ -607,15 +604,14 @@
     }                                                                                   \
                                                                                         \
     Indicator HKU_API func(const KData &k) {                                            \
-        return Indicator(make_shared<Cls_##func>(k));                                   \
+        auto p = make_shared<Cls_##func>();                                             \
+        p->setContext(k);                                                               \
+        return Indicator(p);                                                            \
     }
 
 #define TA_OHLC_OUT1_INT_IMP(func, func_lookback)                                       \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                \
-                                                                                        \
-    Cls_##func::Cls_##func(const KData &k) : IndicatorImp(#func, 1) {                   \
-        setParam<KData>("kdata", k);                                                    \
-        Cls_##func::_calculate(Indicator());                                            \
+    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                 \
+        m_need_context = true;                                                          \
     }                                                                                   \
                                                                                         \
     void Cls_##func::_calculate(const Indicator &data) {                                \
@@ -665,21 +661,18 @@
     }                                                                                   \
                                                                                         \
     Indicator HKU_API func(const KData &k) {                                            \
-        return Indicator(make_shared<Cls_##func>(k));                                   \
+        auto p = make_shared<Cls_##func>();                                             \
+        p->setContext(k);                                                               \
+        return Indicator(p);                                                            \
     }
 
 #define TA_OHLC_OUT1_INT_P1_D_IMP(func, func_lookback, param1, param1_value, param1_min,          \
                                   param1_max)                                                     \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                           \
+        m_need_context = true;                                                                    \
         setParam<double>(#param1, param1_value);                                                  \
     }                                                                                             \
                                                                                                   \
-    Cls_##func::Cls_##func(const KData &k, double p) : IndicatorImp(#func, 1) {                   \
-        setParam<KData>("kdata", k);                                                              \
-        setParam<double>(#param1, p);                                                             \
-        Cls_##func::_calculate(Indicator());                                                      \
-    }                                                                                             \
-                                                                                                  \
     void Cls_##func::_checkParam(const string &name) const {                                      \
         if (name == #param1) {                                                                    \
             double p = getParam<double>(#param1);                                                 \
@@ -737,15 +730,15 @@
     }                                                                                             \
                                                                                                   \
     Indicator HKU_API func(const KData &k, double p) {                                            \
-        return Indicator(make_shared<Cls_##func>(k, p));                                          \
+        auto ptr = make_shared<Cls_##func>();                                                     \
+        ptr->setParam<double>(#param1, p);                                                        \
+        ptr->setContext(k);                                                                       \
+        return Indicator(ptr);                                                                    \
     }
 
 #define TA_HLCV_OUT1_IMP(func, func_lookback)                                           \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                \
-                                                                                        \
-    Cls_##func::Cls_##func(const KData &k) : IndicatorImp(#func, 1) {                   \
-        setParam<KData>("kdata", k);                                                    \
-        Cls_##func::_calculate(Indicator());                                            \
+    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                 \
+        m_need_context = true;                                                          \
     }                                                                                   \
                                                                                         \
     void Cls_##func::_calculate(const Indicator &data) {                                \
@@ -790,15 +783,14 @@
     }                                                                                   \
                                                                                         \
     Indicator HKU_API func(const KData &k) {                                            \
-        return Indicator(make_shared<Cls_##func>(k));                                   \
+        auto ptr = make_shared<Cls_##func>();                                           \
+        ptr->setContext(k);                                                             \
+        return Indicator(ptr);                                                          \
     }
 
 #define TA_HL_OUT1_IMP(func, func_lookback)                                                \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                   \
-                                                                                           \
-    Cls_##func::Cls_##func(const KData &k) : IndicatorImp(#func, 1) {                      \
-        setParam<KData>("kdata", k);                                                       \
-        Cls_##func::_calculate(Indicator());                                               \
+    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                    \
+        m_need_context = true;                                                             \
     }                                                                                      \
                                                                                            \
     void Cls_##func::_calculate(const Indicator &data) {                                   \
@@ -838,15 +830,14 @@
     }                                                                                      \
                                                                                            \
     Indicator HKU_API func(const KData &k) {                                               \
-        return Indicator(make_shared<Cls_##func>(k));                                      \
+        auto ptr = make_shared<Cls_##func>();                                              \
+        ptr->setContext(k);                                                                \
+        return Indicator(ptr);                                                             \
     }
 
 #define TA_CV_OUT1_IMP(func, func_lookback)                                                 \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                    \
-                                                                                            \
-    Cls_##func::Cls_##func(const KData &k) : IndicatorImp(#func, 1) {                       \
-        setParam<KData>("kdata", k);                                                        \
-        Cls_##func::_calculate(Indicator());                                                \
+    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                     \
+        m_need_context = true;                                                              \
     }                                                                                       \
                                                                                             \
     void Cls_##func::_calculate(const Indicator &data) {                                    \
@@ -886,15 +877,14 @@
     }                                                                                       \
                                                                                             \
     Indicator HKU_API func(const KData &k) {                                                \
-        return Indicator(make_shared<Cls_##func>(k));                                       \
+        auto ptr = make_shared<Cls_##func>();                                               \
+        ptr->setContext(k);                                                                 \
+        return Indicator(ptr);                                                              \
     }
 
 #define TA_HLC_OUT1_IMP(func, func_lookback)                                                      \
-    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {}                                          \
-                                                                                                  \
-    Cls_##func::Cls_##func(const KData &k) : IndicatorImp(#func, 1) {                             \
-        setParam<KData>("kdata", k);                                                              \
-        Cls_##func::_calculate(Indicator());                                                      \
+    Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                           \
+        m_need_context = true;                                                                    \
     }                                                                                             \
                                                                                                   \
     void Cls_##func::_calculate(const Indicator &data) {                                          \
@@ -936,20 +926,17 @@
     }                                                                                             \
                                                                                                   \
     Indicator HKU_API func(const KData &k) {                                                      \
-        return Indicator(make_shared<Cls_##func>(k));                                             \
+        auto ptr = make_shared<Cls_##func>();                                                     \
+        ptr->setContext(k);                                                                       \
+        return Indicator(ptr);                                                                    \
     }
 
 #define TA_HLC_OUT1_N_IMP(func, func_lookback, period, period_min, period_max)          \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                 \
+        m_need_context = true;                                                          \
         setParam<int>("n", period);                                                     \
     }                                                                                   \
                                                                                         \
-    Cls_##func::Cls_##func(const KData &k, int n) : IndicatorImp(#func, 1) {            \
-        setParam<KData>("kdata", k);                                                    \
-        setParam<int>("n", n);                                                          \
-        Cls_##func::_calculate(Indicator());                                            \
-    }                                                                                   \
-                                                                                        \
     void Cls_##func::_checkParam(const string &name) const {                            \
         if (name == "n") {                                                              \
             int n = getParam<int>("n");                                                 \
@@ -1001,20 +988,18 @@
     }                                                                                   \
                                                                                         \
     Indicator HKU_API func(const KData &k, int n) {                                     \
-        return Indicator(make_shared<Cls_##func>(k, n));                                \
+        auto p = make_shared<Cls_##func>();                                             \
+        p->setParam<int>("n", n);                                                       \
+        p->setContext(k);                                                               \
+        return Indicator(p);                                                            \
     }
 
 #define TA_HLCV_OUT1_N_IMP(func, func_lookback, period, period_min, period_max)         \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                 \
+        m_need_context = true;                                                          \
         setParam<int>("n", period);                                                     \
     }                                                                                   \
                                                                                         \
-    Cls_##func::Cls_##func(const KData &k, int n) : IndicatorImp(#func, 1) {            \
-        setParam<KData>("kdata", k);                                                    \
-        setParam<int>("n", n);                                                          \
-        Cls_##func::_calculate(Indicator());                                            \
-    }                                                                                   \
-                                                                                        \
     void Cls_##func::_checkParam(const string &name) const {                            \
         if (name == "n") {                                                              \
             int n = getParam<int>("n");                                                 \
@@ -1069,20 +1054,18 @@
     }                                                                                   \
                                                                                         \
     Indicator HKU_API func(const KData &k, int n) {                                     \
-        return Indicator(make_shared<Cls_##func>(k, n));                                \
+        auto p = make_shared<Cls_##func>();                                             \
+        p->setParam<int>("n", n);                                                       \
+        p->setContext(k);                                                               \
+        return Indicator(p);                                                            \
     }
 
 #define TA_HL_OUT1_N_IMP(func, func_lookback, period, period_min, period_max)                 \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                       \
+        m_need_context = true;                                                                \
         setParam<int>("n", period);                                                           \
     }                                                                                         \
                                                                                               \
-    Cls_##func::Cls_##func(const KData &k, int n) : IndicatorImp(#func, 1) {                  \
-        setParam<KData>("kdata", k);                                                          \
-        setParam<int>("n", n);                                                                \
-        Cls_##func::_calculate(Indicator());                                                  \
-    }                                                                                         \
-                                                                                              \
     void Cls_##func::_checkParam(const string &name) const {                                  \
         if (name == "n") {                                                                    \
             int n = getParam<int>("n");                                                       \
@@ -1131,20 +1114,18 @@
     }                                                                                         \
                                                                                               \
     Indicator HKU_API func(const KData &k, int n) {                                           \
-        return Indicator(make_shared<Cls_##func>(k, n));                                      \
+        auto p = make_shared<Cls_##func>();                                                   \
+        p->setParam<int>("n", n);                                                             \
+        p->setContext(k);                                                                     \
+        return Indicator(p);                                                                  \
     }
 
 #define TA_HL_OUT2_N_IMP(func, func_lookback, period, period_min, period_max)                 \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 2) {                                       \
+        m_need_context = true;                                                                \
         setParam<int>("n", period);                                                           \
     }                                                                                         \
                                                                                               \
-    Cls_##func::Cls_##func(const KData &k, int n) : IndicatorImp(#func, 2) {                  \
-        setParam<KData>("kdata", k);                                                          \
-        setParam<int>("n", n);                                                                \
-        Cls_##func::_calculate(Indicator());                                                  \
-    }                                                                                         \
-                                                                                              \
     void Cls_##func::_checkParam(const string &name) const {                                  \
         if (name == "n") {                                                                    \
             int n = getParam<int>("n");                                                       \
@@ -1195,20 +1176,18 @@
     }                                                                                         \
                                                                                               \
     Indicator HKU_API func(const KData &k, int n) {                                           \
-        return Indicator(make_shared<Cls_##func>(k, n));                                      \
+        auto p = make_shared<Cls_##func>();                                                   \
+        p->setParam<int>("n", n);                                                             \
+        p->setContext(k);                                                                     \
+        return Indicator(p);                                                                  \
     }
 
 #define TA_HLC_OUT3_N_IMP(func, func_lookback, period, period_min, period_max)          \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 3) {                                 \
+        m_need_context = true;                                                          \
         setParam<int>("n", period);                                                     \
     }                                                                                   \
                                                                                         \
-    Cls_##func::Cls_##func(const KData &k, int n) : IndicatorImp(#func, 3) {            \
-        setParam<KData>("kdata", k);                                                    \
-        setParam<int>("n", n);                                                          \
-        Cls_##func::_calculate(Indicator());                                            \
-    }                                                                                   \
-                                                                                        \
     void Cls_##func::_checkParam(const string &name) const {                            \
         if (name == "n") {                                                              \
             int n = getParam<int>("n");                                                 \
@@ -1262,20 +1241,18 @@
     }                                                                                   \
                                                                                         \
     Indicator HKU_API func(const KData &k, int n) {                                     \
-        return Indicator(make_shared<Cls_##func>(k, n));                                \
+        auto p = make_shared<Cls_##func>();                                             \
+        p->setParam<int>("n", n);                                                       \
+        p->setContext(k);                                                               \
+        return Indicator(p);                                                            \
     }
 
 #define TA_OC_OUT1_N_IMP(func, func_lookback, period, period_min, period_max)                   \
     Cls_##func::Cls_##func() : IndicatorImp(#func, 1) {                                         \
+        m_need_context = true;                                                                  \
         setParam<int>("n", period);                                                             \
     }                                                                                           \
                                                                                                 \
-    Cls_##func::Cls_##func(const KData &k, int n) : IndicatorImp(#func, 1) {                    \
-        setParam<KData>("kdata", k);                                                            \
-        setParam<int>("n", n);                                                                  \
-        Cls_##func::_calculate(Indicator());                                                    \
-    }                                                                                           \
-                                                                                                \
     void Cls_##func::_checkParam(const string &name) const {                                    \
         if (name == "n") {                                                                      \
             int n = getParam<int>("n");                                                         \
@@ -1324,5 +1301,8 @@
     }                                                                                           \
                                                                                                 \
     Indicator HKU_API func(const KData &k, int n) {                                             \
-        return Indicator(make_shared<Cls_##func>(k, n));                                        \
+        auto p = make_shared<Cls_##func>();                                                     \
+        p->setParam<int>("n", n);                                                               \
+        p->setContext(k);                                                                       \
+        return Indicator(p);                                                                    \
     }

hikyuu/include/hikyuu/plugin/KDataToClickHouseImporter.h

@@ -0,0 +1,40 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-05-06
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/DataType.h"
+#include "interface/ImportKDataToClickHousePluginInterface.h"
+
+namespace hku {
+
+class HKU_API KDataToClickHouseImporter {
+public:
+    KDataToClickHouseImporter();
+    virtual ~KDataToClickHouseImporter();
+
+    bool setConfig(const string& host, int port, const string& user, const string& pwd);
+
+    Datetime getLastDatetime(const string& market, const string& code, const KQuery::KType& ktype);
+
+    void addKRecordList(const string& market, const string& code, const vector<KRecord>& krecords,
+                        const KQuery::KType& ktype);
+
+    void addTimeLineList(const string& market, const string& code, const TimeLineList& timeline);
+
+    void addTransList(const string& market, const string& code, const TransRecordList& translist);
+
+    void updateIndex(const string& market, const string& code, const KQuery::KType& ktype);
+
+    void remove(const string& market, const string& code, const KQuery::KType& ktype,
+                Datetime start);
+
+private:
+    ImportKDataToClickHousePluginInterface* m_plugin{nullptr};
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/plugin/KDataToMySQLImporter.h

@@ -0,0 +1,40 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-05-06
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/DataType.h"
+#include "interface/ImportKDataToMySQLPluginInterface.h"
+
+namespace hku {
+
+class HKU_API KDataToMySQLImporter {
+public:
+    KDataToMySQLImporter();
+    virtual ~KDataToMySQLImporter();
+
+    bool setConfig(const string& host, int port, const string& user, const string& pwd);
+
+    Datetime getLastDatetime(const string& market, const string& code, const KQuery::KType& ktype);
+
+    void addKRecordList(const string& market, const string& code, const vector<KRecord>& krecords,
+                        const KQuery::KType& ktype);
+
+    void addTimeLineList(const string& market, const string& code, const TimeLineList& timeline);
+
+    void addTransList(const string& market, const string& code, const TransRecordList& translist);
+
+    void updateIndex(const string& market, const string& code, const KQuery::KType& ktype);
+
+    void remove(const string& market, const string& code, const KQuery::KType& ktype,
+                Datetime start);
+
+private:
+    ImportKDataToMySQLPluginInterface* m_plugin{nullptr};
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/plugin/checkdata.h

@@ -0,0 +1,20 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-12-20
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/DataType.h"
+#include "interface/CheckDataPluginInterface.h"
+
+namespace hku {
+
+std::pair<std::string, vector<std::string>> HKU_API checkData(const StockList& stock_list,
+                                                              const Datetime& start_date,
+                                                              const Datetime& end_date,
+                                                              const KQuery::KType& check_ktype);
+
+}

hikyuu/include/hikyuu/plugin/extind.h

@@ -191,6 +191,9 @@ Indicator HKU_API AGG_VAR(const Indicator& ind, const KQuery::KType& ktype = KQu
 Indicator HKU_API AGG_QUANTILE(const Indicator& ind, const KQuery::KType& ktype = KQuery::MIN,
                                bool fill_null = false, int unit = 1, double quantile = 0.75);
 
+Indicator HKU_API AGG_VWAP(const KQuery::KType& ktype = KQuery::MIN, bool fill_null = false,
+                           int unit = 1);
+
 using agg_func_t = std::function<double(const DatetimeList& src_ds, const Indicator::value_t* src,
                                         size_t group_start, size_t group_last)>;
 Indicator HKU_API AGG_FUNC(const Indicator& ind, agg_func_t agg_func,

hikyuu/include/hikyuu/plugin/hkuextra.h

@@ -37,6 +37,8 @@ void HKU_API registerExtraKType(const string& ktype, const string& basetype, int
  */
 void HKU_API releaseExtraKType();
 
+void HKU_API enableKDataCache(bool enable);
+
 //-------------------------------
 // 以下函数为内部使用，无需引出
 //-------------------------------
@@ -56,4 +58,6 @@ bool getStockExtraIndexRange(const Stock& stk, const KQuery& query, size_t& out_
 
 KDataImpPtr getKDataImp(const Stock& stk, const KQuery& query);
 
+bool canLazyLoad(const KQuery::KType& ktype);
+
 }  // namespace hku

hikyuu/include/hikyuu/plugin/interface/CheckDataPluginInterface.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-05-19
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/Stock.h"
+#include "hikyuu/utilities/plugin/PluginBase.h"
+
+namespace hku {
+
+class CheckDataPluginInterface : public PluginBase {
+public:
+    CheckDataPluginInterface() = default;
+    virtual ~CheckDataPluginInterface() = default;
+
+    virtual std::pair<std::string, vector<std::string>> checkData(
+      const StockList& stock_list, const Datetime& start_date, const Datetime& end_date,
+      const KQuery::KType& check_ktype) = 0;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/plugin/interface/HkuExtraPluginInterface.h

@@ -35,6 +35,10 @@ public:
                                          size_t& out_end) = 0;
 
     virtual KDataImpPtr getKDataImp(const Stock& stk, const KQuery& query) = 0;
+
+    virtual bool canLazyLoad(const KQuery::KType& ktype) = 0;
+
+    virtual void enableKDataCache(bool enable) = 0;
 };
 
 }  // namespace hku

hikyuu/include/hikyuu/plugin/interface/ImportKDataToClickHousePluginInterface.h

@@ -0,0 +1,44 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-04-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/KRecord.h"
+#include "hikyuu/KQuery.h"
+#include "hikyuu/TimeLineRecord.h"
+#include "hikyuu/TransRecord.h"
+#include "hikyuu/utilities/plugin/PluginBase.h"
+
+namespace hku {
+
+class ImportKDataToClickHousePluginInterface : public PluginBase {
+public:
+    ImportKDataToClickHousePluginInterface() = default;
+    virtual ~ImportKDataToClickHousePluginInterface() = default;
+
+    virtual bool setConfig(const string& host, int port, const string& user, const string& pwd) = 0;
+
+    virtual Datetime getLastDatetime(const string& market, const string& code,
+                                     const KQuery::KType& ktype) = 0;
+
+    virtual void addKRecordList(const string& market, const string& code,
+                                const vector<KRecord>& krecords, const KQuery::KType& ktype) = 0;
+
+    virtual void addTimeLineList(const string& market, const string& code,
+                                 const TimeLineList& timeline) = 0;
+
+    virtual void addTransList(const string& market, const string& code,
+                              const TransRecordList& translist) = 0;
+
+    virtual void updateIndex(const string& market, const string& code,
+                             const KQuery::KType& ktype) = 0;
+
+    virtual void remove(const string& market, const string& code, const KQuery::KType& ktype,
+                        Datetime start) = 0;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/plugin/interface/ImportKDataToMySQLPluginInterface.h

@@ -0,0 +1,42 @@
+/*
+ *  Copyright (c) 2025 hikyuu.org
+ *
+ *  Created on: 2025-04-08
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include "hikyuu/KRecord.h"
+#include "hikyuu/KQuery.h"
+#include "hikyuu/utilities/plugin/PluginBase.h"
+
+namespace hku {
+
+class ImportKDataToMySQLPluginInterface : public PluginBase {
+public:
+    ImportKDataToMySQLPluginInterface() = default;
+    virtual ~ImportKDataToMySQLPluginInterface() = default;
+
+    virtual bool setConfig(const string& host, int port, const string& user, const string& pwd) = 0;
+
+    virtual Datetime getLastDatetime(const string& market, const string& code,
+                                     const KQuery::KType& ktype) = 0;
+
+    virtual void addKRecordList(const string& market, const string& code,
+                                const vector<KRecord>& krecords, const KQuery::KType& ktype) = 0;
+
+    virtual void updateIndex(const string& market, const string& code,
+                             const KQuery::KType& ktype) = 0;
+
+    virtual void addTimeLineList(const string& market, const string& code,
+                                 const TimeLineList& timeline) = 0;
+
+    virtual void addTransList(const string& market, const string& code,
+                              const TransRecordList& translist) = 0;
+
+    virtual void remove(const string& market, const string& code, const KQuery::KType& ktype,
+                        Datetime start) = 0;
+};
+
+}  // namespace hku

hikyuu/include/hikyuu/plugin/interface/plugins.h

@@ -13,10 +13,13 @@
 #include "DevicePluginInterface.h"
 #include "DataServerPluginInterface.h"
 #include "ImportKDataToHdf5PluginInterface.h"
+#include "ImportKDataToClickHousePluginInterface.h"
+#include "ImportKDataToMySQLPluginInterface.h"
 #include "ExtendIndicatorsPluginInterface.h"
 #include "TMReportPluginInterface.h"
 #include "DataDriverPluginInterface.h"
 #include "HkuExtraPluginInterface.h"
+#include "CheckDataPluginInterface.h"
 
 namespace hku {
 
@@ -24,9 +27,12 @@ namespace hku {
 #define HKU_PLUGIN_DEVICE "device"
 #define HKU_PLUGIN_DATASERVER "dataserver"
 #define HKU_PLUGIN_IMPORTKDATATOHDF5 "import2hdf5"
+#define HKU_PLUGIN_IMPORTKDATATOCLICKHOUSE "import2ch"
+#define HKU_PLUGIN_IMPORTKDATATOMYSQL "import2mysql"
 #define HKU_PLUGIN_EXTEND_INDICATOR "extind"
 #define HKU_PLUGIN_TMREPORT "tmreport"
 #define HKU_PLUGIN_CLICKHOUSE_DRIVER "clickhousedriver"
 #define HKU_PLUGIN_HKU_EXTRA "hkuextra"
+#define HKU_PLUGIN_CHECK_DATA "checkdata"
 
 }  // namespace hku