hikyuu 2.6.8__py3-none-manylinux2014_aarch64.whl

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

@@ -0,0 +1,62 @@
+/*
+ *  Copyright(C) 2021 hikyuu.org
+ *
+ *  Create on: 2021-06-26
+ *     Author: fasiondog
+ */
+
+#pragma once
+
+#include <fmt/format.h>
+#include "hikyuu/utilities/exception.h"
+
+namespace hku {
+
+/** SQL 处理异常, 主要用于封装具体数据库引擎内部错误 */
+class SQLException : public hku::exception {
+public:
+    /** 默认构造函数 */
+    SQLException() : SQLException(0, "Unknow error!") {}
+
+    /**
+     * 构造 SQLite 异常
+     * @param errcode SQLite错误码
+     * @param msg SQLite错误信息
+     */
+    SQLException(int errcode, const std::string& msg)
+    : hku::exception(fmt::format("{} (errcode: {})", msg, errcode)), m_errcode(errcode) {}
+
+    /**
+     * 构造 SQLite 异常
+     * @param errcode SQLite错误码
+     * @param msg SQLite错误信息
+     */
+    SQLException(int errcode, const char* msg)
+    : hku::exception(fmt::format("{} (errcode: {})", msg, errcode)), m_errcode(errcode) {}
+
+    /** 获取 SQLite 错误码 */
+    int errcode() const {
+        return m_errcode;
+    }
+
+private:
+    int m_errcode;
+};
+
+#define SQL_CHECK(expr, errcode, ...)                                                            \
+    do {                                                                                         \
+        if (!(expr)) {                                                                           \
+            throw SQLException(                                                                  \
+              errcode, fmt::format("SQL_CHECK({}) {} [{}] ({}:{})", #expr,                       \
+                                   fmt::format(__VA_ARGS__), __FUNCTION__, __FILE__, __LINE__)); \
+        }                                                                                        \
+    } while (0)
+
+#define SQL_THROW(errcode, ...)                                                                    \
+    do {                                                                                           \
+        throw SQLException(errcode,                                                                \
+                           fmt::format("SQL_EXCEPTION: {} [{}] ({}:{})", fmt::format(__VA_ARGS__), \
+                                       __FUNCTION__, __FILE__, __LINE__));                         \
+    } while (0)
+
+}  // namespace hku

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

@@ -0,0 +1,248 @@
+/*
+ *  Copyright (c) 2023 hikyuu.org
+ *
+ *  Created on: 2023-01-10
+ *      Author: fasiondog
+ */
+
+#pragma once
+
+#include <iterator>
+#include "hikyuu/utilities/arithmetic.h"
+#include "hikyuu/utilities/Log.h"
+#include "hikyuu/utilities/osdef.h"
+#include "DBConnectBase.h"
+
+namespace hku {
+
+template <class TableT, size_t page_size>
+class SQLResultSetIterator;
+
+/**
+ * SQL查询结果集
+ * @tparam TableT 数据结构
+ * @tparam page_size 每页包含的数据数量
+ * @ingroup DBConnect
+ */
+template <class TableT, size_t page_size = 100>
+class SQLResultSet {
+    friend class SQLResultSetIterator<TableT, page_size>;
+
+public:
+#if CPP_STANDARD >= CPP_STANDARD_17
+    static constexpr int PSIZE = page_size;
+#else
+    static const int PSIZE = page_size;
+#endif
+
+    SQLResultSet() = default;
+
+    /**
+     * 构建新的分页查询结果实例
+     * @param connect
+     * @param sql
+     */
+    SQLResultSet(const DBConnectPtr& connect, const std::string& sql)
+    : m_connect(connect),
+      m_where(sql),
+      m_sql_template("id IN (SELECT id FROM {} WHERE {} {} LIMIT {} OFFSET {}) {}") {
+        trim(m_where);
+        if (m_where.empty()) {
+            m_where = "1=1";
+            m_orderby_inner = "ORDER BY id";
+            // m_orderby_outer = "";
+            return;
+        }
+
+        std::string tmp(m_where);
+        to_upper(tmp);
+        size_t pos = tmp.rfind("ORDER");
+        if (pos != std::string::npos) {
+            m_orderby_inner = fmt::format("{}, id ASC", m_where.substr(pos));
+            m_orderby_outer = m_orderby_inner;
+            m_where = m_where.erase(pos, std::string::npos);
+        } else {
+            m_orderby_inner = "ORDER BY id";
+        }
+    }
+
+    /** 获取其数据库连接 */
+    const DBConnectPtr& getConnect() const {
+        return m_connect;
+    }
+
+    using const_iterator = SQLResultSetIterator<TableT, page_size>;
+    using iterator = SQLResultSetIterator<TableT, page_size>;
+
+    const_iterator cbegin() {
+        return const_iterator(this, 0);
+    }
+
+    const_iterator cend() {
+        return const_iterator(this, Null<size_t>());
+    }
+
+    iterator begin() {
+        return iterator(this, 0);
+    }
+
+    iterator end() {
+        return iterator(this, Null<size_t>());
+    }
+
+    /**
+     * @brief 获取当前时刻数据集大小
+     * @note 数据集大小会根据当前的数据库内容发生变化，并非一直不变
+     * @return size_t
+     */
+    size_t size() const {
+        HKU_IF_RETURN(!m_connect, 0);
+        std::string sql =
+          fmt::format("select count(1) from {} where {}", TableT::getTableName(), m_where);
+        return m_connect->queryNumber<size_t>(sql, 0);
+    }
+
+    /**
+     * @brief 当前数据集是否为空
+     * @return true 空
+     * @return false 非空
+     */
+    bool empty() const {
+        return size() == 0;
+    }
+
+    /**
+     * @brief 获取当前数据集分页数量
+     * @note 仅为调用时刻获取的相应数据集分页数量
+     * @return size_t
+     */
+    size_t getPageCount() {
+        size_t total = size();
+        size_t n = total / page_size;
+        return n * page_size > total ? n : n + 1;
+    }
+
+    /**
+     * @brief 获取指定页中的全部数据
+     * @param page 指定页
+     * @return std::vector<TableT> 该页包含的所有有效数据集
+     */
+    std::vector<TableT> getPage(size_t page) {
+        std::vector<TableT> result;
+        m_connect->batchLoad(
+          result, fmt::format(m_sql_template, TableT::getTableName(), m_where, m_orderby_inner,
+                              page_size, page * page_size, m_orderby_outer));
+        return result;
+    }
+
+    TableT operator[](size_t index) {
+        return get(index);
+    }
+
+    TableT at(size_t index) {
+        TableT result = get(index);
+        HKU_CHECK_THROW(result.valid(), std::out_of_range, "Index is over");
+        return result;
+    }
+
+private:
+    TableT get(size_t index) {
+        TableT result{Null<TableT>()};
+        HKU_IF_RETURN(index == Null<size_t>(), result);
+
+        size_t page = index / page_size;
+        if (m_connect && page != m_current_page) {
+            m_buffer.clear();
+            m_connect->batchLoad(
+              m_buffer, fmt::format(fmt::runtime(m_sql_template), TableT::getTableName(), m_where,
+                                    m_orderby_inner, page_size, page * page_size, m_orderby_outer));
+            m_current_page = page;
+        }
+
+        HKU_IF_RETURN(m_buffer.empty(), result);
+
+        size_t pos = index - page * page_size;
+        HKU_IF_RETURN(pos >= m_buffer.size(), result);
+
+        result = m_buffer[index - page * page_size];
+        return result;
+    }
+
+private:
+    DBConnectPtr m_connect;
+    std::vector<TableT> m_buffer;
+    std::string m_where;
+    std::string m_sql_template;
+    std::string m_orderby_inner;
+    std::string m_orderby_outer;
+    size_t m_current_page = Null<size_t>();
+};
+
+template <class TableT, size_t page_size>
+class SQLResultSetIterator {
+public:
+    using ResultSet = SQLResultSet<TableT, page_size>;
+
+    SQLResultSetIterator() = default;
+    ~SQLResultSetIterator() = default;
+
+    explicit SQLResultSetIterator(ResultSet* result_set, size_t index)
+    : m_set(result_set), m_index(index) {
+        if (m_index != Null<size_t>()) {
+            m_value = std::move(m_set->get(index));
+            if (!m_value.valid()) {
+                m_index = Null<size_t>();
+            }
+        }
+    }
+
+    SQLResultSetIterator(const SQLResultSetIterator& other)
+    : m_set(other.m_set), m_index(other.m_index) {}
+
+    SQLResultSetIterator& operator=(const SQLResultSetIterator& other) {
+        if (this == &other)
+            return *this;
+        m_index = other.m_index;
+        m_set = other.m_set;
+        return *this;
+    }
+
+    const TableT& operator*() const {
+        return m_value;
+    }
+
+    TableT& operator*() {
+        return m_value;
+    }
+
+    const TableT* const operator->() const {
+        return &m_value;
+    }
+
+    TableT* operator->() {
+        return &m_value;
+    }
+
+    // Prefix increment operator
+    SQLResultSetIterator& operator++() {
+        HKU_CHECK_THROW(m_index != Null<size_t>(), std::logic_error,
+                        "Cannot increment an end iterator.");
+        m_index++;
+        m_value = std::move(m_set->get(m_index));
+        if (!m_value.valid()) {
+            m_index = Null<size_t>();
+        }
+        return *this;
+    }
+
+    bool operator!=(const SQLResultSetIterator& iter) const {
+        return m_index != iter.m_index;
+    }
+
+private:
+    ResultSet* m_set = nullptr;
+    size_t m_index = Null<size_t>();
+    TableT m_value;
+};
+
+}  // namespace hku

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

@@ -0,0 +1,305 @@
+/*
+ * SQLStatemantBase.h
+ *
+ *  Copyright (c) 2019, hikyuu.org
+ *
+ *  Created on: 2019-7-11
+ *      Author: fasiondog
+ */
+#pragma once
+#ifndef HIKYUU_DB_CONNECT_SQLSTATEMENTBASE_H
+#define HIKYUU_DB_CONNECT_SQLSTATEMENTBASE_H
+
+#include <type_traits>
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/archive/binary_oarchive.hpp>
+#include "hikyuu/utilities/datetime/Datetime.h"
+#include "../../DataType.h"
+
+namespace hku {
+
+class DBConnectBase;
+
+/** @ingroup DBConnect */
+typedef std::shared_ptr<DBConnectBase> DBConnectPtr;
+
+/** @ingroup DBConnect */
+class null_blob_exception : public exception {
+public:
+    /** 构造 */
+    null_blob_exception() : exception("Blob is null!") {}
+};
+
+/**
+ * SQL Statement 基类
+ * @ingroup DBConnect
+ */
+class HKU_UTILS_API SQLStatementBase {
+public:
+    /**
+     * 构造函数
+     * @param driver 数据库连接
+     * @param sql_statement SQL语句
+     */
+    SQLStatementBase(DBConnectBase *driver, const std::string &sql_statement);
+
+    virtual ~SQLStatementBase() = default;
+
+    /** 获取构建时传入的表达式SQL语句 */
+    const std::string &getSqlString() const;
+
+    /** 获取数据驱动 */
+    DBConnectBase *getConnect() const;
+
+    /** 执行 SQL */
+    void exec();
+
+    /** 移动至下一结果 */
+    bool moveNext();
+
+    /** 将 null 绑定至 idx 指定的 SQL 参数中 */
+    void bind(int idx);  // bind_null
+
+    /** 将 item 的值绑定至 idx 指定的 SQL 参数中 */
+    void bind(int idx, float item);
+
+    /** 将 item 的值绑定至 idx 指定的 SQL 参数中 */
+    void bind(int idx, double item);
+
+    /** 将 item 的值绑定至 idx 指定的 SQL 参数中 */
+    void bind(int idx, const std::string &item);
+
+    /** 将字符串类型 item 绑定至 idx 指定的 SQL 参数中 */
+    void bind(int idx, const char *item, size_t len);
+
+    /** 将 Datetime 类型 item 绑定至指定的 SQL 参数中 */
+    void bind(int idx, const Datetime &item);
+
+    /** 将 item 的值绑定至 idx 指定的 SQL 参数中 */
+    void bindBlob(int idx, const std::string &item);
+
+    /**
+     * 将 item 的值绑定至 idx 指定的 SQL 参数中
+     */
+    void bindBlob(int idx, const std::vector<char> &time);
+
+    /** 将 item 的值绑定至 idx 指定的 SQL 参数中 */
+    template <typename T>
+    typename std::enable_if<std::numeric_limits<T>::is_integer>::type bind(int idx, const T &item);
+
+    /** 将 item 的值绑定至 idx 指定的 SQL 参数中 */
+    template <typename T>
+    typename std::enable_if<!std::numeric_limits<T>::is_integer>::type bind(int idx, const T &item);
+
+    void bind(int idx, const std::vector<char> &item);
+
+    /** 将 item 的值绑定至 idx 指定的 SQL 参数中 */
+    template <typename T, typename... Args>
+    void bind(int idx, const T &, const Args &...rest);
+
+    /** 获取执行INSERT时最后插入记录的 rowid，非线程安全 */
+    uint64_t getLastRowid();
+
+    /** 获取表格列数 */
+    int getNumColumns() const;
+
+    /** 获取 idx 指定的数据至 item */
+    void getColumn(int idx, double &item);
+
+    /** 获取 idx 指定的数据至 item */
+    void getColumn(int idx, float &item);
+
+    /** 获取 idx 指定的数据至 item */
+    void getColumn(int idx, std::string &item);
+
+    /** 获取 idx 指定的数据至 item */
+    void getColumn(int idx, Datetime &item);
+
+    void getColumn(int idx, std::vector<char> &);
+
+    /** 获取 idx 指定的数据至 item */
+    template <typename T>
+    typename std::enable_if<std::numeric_limits<T>::is_integer>::type getColumn(int idx, T &);
+
+    /** 获取 idx 指定的数据至 item */
+    template <typename T>
+    typename std::enable_if<!std::numeric_limits<T>::is_integer>::type getColumn(int idx, T &);
+
+    /** 以指定 idx 开始顺序获取指定的数据至 item1, item2, item3 */
+    template <typename T, typename... Args>
+    void getColumn(int idx, T &, Args &...rest);
+
+    //-------------------------------------------------------------------------
+    // 子类接口
+    //-------------------------------------------------------------------------
+    virtual void sub_exec() = 0;              ///< 子类接口 @see exec
+    virtual bool sub_moveNext() = 0;          ///< 子类接口 @see moveNext
+    virtual uint64_t sub_getLastRowid() = 0;  ///< 子类接口 @see getLastRowid();
+
+    virtual void sub_bindNull(int idx) = 0;                            ///< 子类接口 @see bind
+    virtual void sub_bindInt(int idx, int64_t value) = 0;              ///< 子类接口 @see bind
+    virtual void sub_bindDouble(int idx, double item) = 0;             ///< 子类接口 @see bind
+    virtual void sub_bindDatetime(int idx, const Datetime &item) = 0;  ///< 子类接口 @see bind
+    virtual void sub_bindText(int idx, const std::string &item) = 0;   ///< 子类接口 @see bind
+    virtual void sub_bindText(int idx, const char *item, size_t len) = 0;  ///< 子类接口 @see bind
+    virtual void sub_bindBlob(int idx, const std::string &item) = 0;  ///< 子类接口 @see bind
+    virtual void sub_bindBlob(int idx, const std::vector<char> &item) = 0;  ///< 子类接口 @see bind
+
+    virtual int sub_getNumColumns() const = 0;                  ///< 子类接口 @see getNumColumns
+    virtual void sub_getColumnAsInt64(int idx, int64_t &) = 0;  ///< 子类接口 @see getColumn
+    virtual void sub_getColumnAsDouble(int idx, double &) = 0;  ///< 子类接口 @see getColumn
+    virtual void sub_getColumnAsDatetime(int idx, Datetime &) = 0;  ///< 子类接口 @see getColumn
+    virtual void sub_getColumnAsText(int idx, std::string &) = 0;   ///< 子类接口 @see getColumn
+    virtual void sub_getColumnAsBlob(int idx, std::string &) = 0;   ///< 子类接口 @see getColumn
+    virtual void sub_getColumnAsBlob(int idx,
+                                     std::vector<char> &) = 0;  ///< 子类接口 @see getColumn
+
+private:
+    SQLStatementBase() = delete;
+
+protected:
+    DBConnectBase *m_driver;   ///< 数据库连接
+    std::string m_sql_string;  ///< 原始 SQL 语句
+};
+
+/** @ingroup DBConnect */
+typedef std::shared_ptr<SQLStatementBase> SQLStatementPtr;
+
+inline SQLStatementBase ::SQLStatementBase(DBConnectBase *driver, const std::string &sql_statement)
+: m_driver(driver), m_sql_string(sql_statement) {
+    HKU_CHECK(driver, "driver is null!");
+}
+
+inline const std::string &SQLStatementBase::getSqlString() const {
+    return m_sql_string;
+}
+
+inline DBConnectBase *SQLStatementBase::getConnect() const {
+    return m_driver;
+}
+
+inline void SQLStatementBase::bind(int idx, float item) {
+    bind(idx, (double)item);
+}
+
+inline void SQLStatementBase::exec() {
+#if HKU_SQL_TRACE
+    HKU_DEBUG(m_sql_string);
+#endif
+    sub_exec();
+}
+
+inline bool SQLStatementBase::moveNext() {
+    return sub_moveNext();
+}
+
+inline void SQLStatementBase::bind(int idx) {
+    sub_bindNull(idx);
+}
+
+inline void SQLStatementBase::bind(int idx, const std::string &item) {
+    sub_bindText(idx, item);
+}
+
+inline void SQLStatementBase::bind(int idx, double item) {
+    sub_bindDouble(idx, item);
+}
+
+inline void SQLStatementBase::bind(int idx, const Datetime &item) {
+    sub_bindDatetime(idx, item);
+}
+
+inline void SQLStatementBase::bindBlob(int idx, const std::string &item) {
+    sub_bindBlob(idx, item);
+}
+
+inline void SQLStatementBase::bindBlob(int idx, const std::vector<char> &item) {
+    sub_bindBlob(idx, item);
+}
+
+inline uint64_t SQLStatementBase::getLastRowid() {
+    return sub_getLastRowid();
+}
+
+inline int SQLStatementBase::getNumColumns() const {
+    return sub_getNumColumns();
+}
+
+inline void SQLStatementBase::getColumn(int idx, double &item) {
+    sub_getColumnAsDouble(idx, item);
+}
+
+inline void SQLStatementBase::getColumn(int idx, float &item) {
+    double temp;
+    sub_getColumnAsDouble(idx, temp);
+    item = (float)temp;
+}
+
+inline void SQLStatementBase::getColumn(int idx, Datetime &item) {
+    sub_getColumnAsDatetime(idx, item);
+}
+
+inline void SQLStatementBase::getColumn(int idx, std::string &item) {
+    sub_getColumnAsText(idx, item);
+}
+
+inline void SQLStatementBase::bind(int idx, const std::vector<char> &item) {
+    sub_bindBlob(idx, item);
+}
+
+template <typename T>
+typename std::enable_if<std::numeric_limits<T>::is_integer>::type SQLStatementBase::bind(
+  int idx, const T &item) {
+    sub_bindInt(idx, item);
+}
+
+template <typename T>
+typename std::enable_if<!std::numeric_limits<T>::is_integer>::type SQLStatementBase::bind(
+  int idx, const T &item) {
+    std::ostringstream sout;
+    boost::archive::binary_oarchive oa(sout);
+    oa << BOOST_SERIALIZATION_NVP(item);
+    sub_bindBlob(idx, sout.str());
+}
+
+template <typename T>
+typename std::enable_if<std::numeric_limits<T>::is_integer>::type SQLStatementBase::getColumn(
+  int idx, T &item) {
+    int64_t temp;
+    sub_getColumnAsInt64(idx, temp);
+    item = (T)temp;
+}
+
+inline void SQLStatementBase::getColumn(int idx, std::vector<char> &item) {
+    sub_getColumnAsBlob(idx, item);
+}
+
+template <typename T>
+typename std::enable_if<!std::numeric_limits<T>::is_integer>::type SQLStatementBase::getColumn(
+  int idx, T &item) {
+    std::string tmp;
+    try {
+        sub_getColumnAsBlob(idx, tmp);
+    } catch (null_blob_exception &) {
+        return;
+    }
+    std::istringstream sin(tmp);
+    boost::archive::binary_iarchive ia(sin);
+    ia >> BOOST_SERIALIZATION_NVP(item);
+}
+
+template <typename T, typename... Args>
+void SQLStatementBase::bind(int idx, const T &item, const Args &...rest) {
+    bind(idx, item);
+    bind(idx + 1, rest...);
+}
+
+template <typename T, typename... Args>
+void SQLStatementBase::getColumn(int idx, T &item, Args &...rest) {
+    getColumn(idx, item);
+    getColumn(idx + 1, rest...);
+}
+
+}  // namespace hku
+
+#endif /* HIKYUU_DB_CONNECT_SQLSTATEMENTBASE_H */