kaq-quant-common 0.2.12__py3-none-any.whl

kaq_quant_common/common/statistics/funding_rate_history_statistics.py

@@ -0,0 +1,208 @@
+import datetime
+import json
+from typing import Optional
+
+import pandas as pd
+from pydantic import BaseModel
+
+from kaq_quant_common.common.statistics.kline_history_statistics import \
+    StatisticsInfo
+from kaq_quant_common.utils import logger_utils
+
+platforms = ["binance", "bitget", "bybit", "gate", "htx", "okx"]
+
+
+# 这个类是统计合约历史资金数据的，在确保已经抓取完数据后使用
+class FuturesFundingRateHistoryStatistics:
+    def __init__(
+        self,
+        begin_timestamp: int,
+        end_timestamp: int,
+        symbols: list[str],
+        master: str,
+        redis: None,
+        mysql: None,
+    ):
+        self.redis_key = "kaq_futures_funding_rate_history_statistics"
+        self.begin_timestamp = begin_timestamp
+        self.end_timestamp = end_timestamp
+        self.symbols = symbols
+        # 计算天数
+        self.day_num = (end_timestamp - begin_timestamp) // (24 * 3600 * 1000)
+        self._redis = redis
+        self._mysql = mysql
+        self.master = master
+        self._logger = logger_utils.get_logger()
+        self.table_name = "kaq_futures_funding_rate_history"
+
+    # 针对本平台的所有交易对每个进行对应统计
+    def symbols_statistics(self):
+        for symbol in self.symbols:
+            try:
+                self.get_symbol_funding_rate_all_platform(symbol)
+            except Exception as e:
+                self._logger.error(f"拉取{symbol}的资金数据出现异常: {e}")
+                ddd = 1
+                continue
+
+    # 对指定交易对进行全平台的资金数据拉取
+    def get_symbol_funding_rate_all_platform(self, symbol: str):
+        df_dict = {}
+        # 先拉自己的吧
+        master_df = self.query_symbol_funding_rate_data(symbol, self.master)
+
+        # 先记录下主平台拉到的数据量，用来对比其它平台，其它平台不是这么多就证明有问题，需要记录下日志
+        master_df_len = len(master_df)
+
+        # 没有数据就跳过
+        if master_df_len == 0:
+            raise Exception(
+                f"{self.master}平台拉取到的{symbol}的资金数据量为：{master_df_len}条，跳过后续处理"
+            )
+
+        # 对其它交易所进行拉取
+        for platform in platforms:
+            if platform == self.master:
+                continue
+            platform_df = self.query_symbol_funding_rate_data(symbol, platform)
+
+            if len(platform_df) != master_df_len:
+                self._logger.error(
+                    f"{platform}平台拉取到的{symbol}的资金数据量与主平台不一致，主平台：{master_df_len},{platform}平台：{len(platform_df)}，跳过该交易所数据"
+                )
+                continue
+
+            df_dict[platform] = platform_df
+
+        #  开始计算差异
+        symbol_diffrenence_dict = self.calculate_funding_rate_difference(
+            symbol, master_df, df_dict
+        )
+
+        self._redis.hset(
+            self.redis_key + ":" + self.master.upper(),
+            symbol,
+            json.dumps({k: v.model_dump() for k, v in symbol_diffrenence_dict.items()}),
+        )
+
+    # 计算各个平台的资金数据差异
+    def calculate_funding_rate_difference(
+        self, symbol: str, master_df: pd.DataFrame, df_dict: dict
+    ):
+        res = {}
+        master_hour = master_df.iloc[0]["hour"]
+        # 自己也要计算差异
+        master_std = master_df[f"{self.master}_rate"].std()
+        master_mean = master_df[f"{self.master}_rate"].mean()
+        master_max = master_df[f"{self.master}_rate"].max()
+        master_rate_corr = master_df[f"{self.master}_rate"].corr(
+            master_df["event_time_hour"]
+        )
+        master_min = master_df[f"{self.master}_rate"].min()
+        master_quantile = master_df[f"{self.master}_rate"].quantile([0.25, 0.5, 0.75])
+
+        res[self.master] = StatisticsInfo(
+            platform=self.master,
+            std=master_std,
+            mean=master_mean,
+            max=master_max,
+            corr=master_rate_corr,
+            min=master_min,
+            quantile={str(k): float(v) for k, v in master_quantile.to_dict().items()},
+            period=master_hour,
+        )
+
+        # 还要加主平台的差异，主平台不需要减，只需要直接处理
+        for platform, platform_df in df_dict.items():
+            platform_hour = platform_df.iloc[0]["hour"]
+            # 合并数据，找出差异
+            merged_df = pd.merge(
+                master_df, platform_df, on=["symbol", "event_time_hour"], how="inner"
+            )
+
+            # 计算差值
+            merged_df["rate_diff"] = (
+                merged_df[f"{self.master}_rate"] - merged_df[f"{platform}_rate"]
+            )
+            # 标准差
+            rate_std = merged_df["rate_diff"].std()
+            # 平均值
+            rate_mean = merged_df["rate_diff"].mean()
+            # 最大值
+            rate_max = merged_df["rate_diff"].max()
+            # 皮尔逊系数(斜率)
+            rate_corr = merged_df["rate_diff"].corr(merged_df["event_time_hour"])
+            # 最小值
+            rate_min = merged_df["rate_diff"].min()
+            # 4分位数
+            rate_quantile = merged_df["rate_diff"].quantile([0.25, 0.5, 0.75])
+            # self._logger.info(
+            #     f"{self.master}与{platform}平台的{symbol}的K线差异统计: 标准差={rate_std}, 平均值={rate_mean}, 最大值={rate_max}, 最小值={rate_min}, 皮尔逊系数={rate_corr}, 四分位数={rate_quantile.to_dict()}"
+            # )
+            res[platform] = StatisticsInfo(
+                platform=platform,
+                std=rate_std,
+                mean=rate_mean,
+                max=rate_max,
+                corr=rate_corr,
+                min=rate_min,
+                quantile={str(k): v for k, v in rate_quantile.to_dict().items()},
+                period=platform_hour,
+            )
+
+        return res
+
+    # 拉指定时间指定symbol的资金数据
+    def query_symbol_funding_rate_data(self, symbol: str, platform: str):
+        sql_result_df = pd.DataFrame()
+        # 先转成周一日期来定表名，因为数据表是按周来分表的
+        sql = f"select exchange, symbol, rate as {platform}_rate, event_time from {self.table_name} where symbol = '{symbol}' and event_time >= {self.begin_timestamp} and event_time < {self.end_timestamp} and exchange='{platform}' order by event_time desc ;"
+        result = self._mysql.fetch_data(sql)
+        sql_result_df = pd.DataFrame(result)
+        if sql_result_df.empty:
+            return sql_result_df
+        # 转换类型
+        sql_result_df[f"{platform}_rate"] = sql_result_df[f"{platform}_rate"].astype(
+            float
+        )
+        # 增加个周期字段用来补全24小时数据
+        # 我操，接口拿到的event_time毫秒有些不是整点，转成小时处理吧。
+        sql_result_df["event_time"] = sql_result_df["event_time"].astype(int)
+        sql_result_df["event_time_hour"] = sql_result_df["event_time"] // 1000
+        # 计算周期
+        sql_result_df["period"] = sql_result_df["event_time_hour"].diff(periods=-1)
+        sql_result_df["hour"] = sql_result_df["period"] // 3600
+
+        sql_result_df = sql_result_df[::-1]  # 反向排序
+
+        start_ts = int(sql_result_df["event_time"].iloc[0])
+        start_dt = pd.to_datetime(start_ts // 1000, unit="s")
+        # 先生成一批完整的时间序列数据
+        temp_date_df = pd.date_range(
+            start_dt,
+            periods=self.day_num * 24,
+            freq="h",
+        )
+        temp_date_df = temp_date_df[::-1]  # 反向排序
+
+        # 生成完整的毫秒级时间戳DataFrame
+        temp_time_df = pd.DataFrame(
+            {"event_time_hour": temp_date_df.astype(int) // 10**9}  # 转为毫秒
+        )
+        # 合并，左侧为完整时间
+        merged_df = temp_time_df.merge(sql_result_df, on="event_time_hour", how="left")
+        # 向上对齐填充
+        merged_df = merged_df.sort_values("event_time_hour").ffill()
+        # event_time用自身时间，其它字段用ffill
+        merged_df["event_time_hour"] = temp_time_df["event_time_hour"]
+        merged_df = merged_df.sort_values(
+            "event_time_hour", ascending=False
+        ).reset_index(drop=True)
+        return merged_df
+
+
+if __name__ == "__main__":
+    klineStatistics = FuturesFundingRateHistoryStatistics(
+        1765296000000, 1765382400000, ["BTCUSDT", "ETHUSDT"]
+    )
+    klineStatistics.symbols_statistics()

kaq_quant_common/common/statistics/kline_history_statistics.py

@@ -0,0 +1,211 @@
+import datetime
+import json
+from typing import Optional
+
+import pandas as pd
+from pydantic import BaseModel
+
+from kaq_quant_common.utils import logger_utils
+
+platforms = ["binance", "bitget", "bybit", "gate", "htx", "okx"]
+
+
+# 对比结果结构体
+class StatisticsInfo(BaseModel):
+    # 对比平台
+    platform: str
+    # 标准差
+    std: float
+    # 平均值
+    mean: float
+    # 最大值
+    max: float
+    # 皮尔逊系数(斜率)
+    corr: float
+    # 最小值
+    min: float
+    # 4分位数
+    quantile: dict[str, float]
+    # 相隔时间(hour)
+    period: Optional[int] = 0
+
+
+# 这个类是统计合约K线历史数据的，在确保已经抓取完数据后使用
+class FuturesKlineHistoryStatistics:
+    def __init__(
+        self,
+        begin_timestamp: int,
+        end_timestamp: int,
+        symbols: list[str],
+        master: str,
+        redis: None,
+        mysql: None,
+    ):
+        self.redis_key = "kaq_futures_kline_history_statistics"
+        self.begin_timestamp = begin_timestamp
+        self.end_timestamp = end_timestamp
+        self.symbols = symbols
+        # 计算天数，每天都会有1440条数据
+        self.day_num = (end_timestamp - begin_timestamp) // (24 * 3600 * 1000)
+        self._redis = redis
+        self._mysql = mysql
+        self.master = master
+        self._logger = logger_utils.get_logger()
+
+    # 针对本平台的所有交易对每个进行对应统计
+    def symbols_statistics(self):
+        for symbol in self.symbols:
+            try:
+                self.get_symbol_kline_all_platform(symbol)
+            except Exception as e:
+                self._logger.error(f"拉取{symbol}的K线数据出现异常: {e}")
+                continue
+
+    # 对指定交易对进行全平台的K线拉取
+    def get_symbol_kline_all_platform(self, symbol: str):
+        df_dict = {}
+        # 先拉自己的吧
+        master_df = self.query_symbol_line_data(symbol, self.master)
+
+        # 不够数据也跳过
+        if len(master_df) < 1440 * self.day_num:
+            raise Exception(
+                f"{self.master}平台拉取到的{symbol}的K线数据量不足{1440 * self.day_num}条，跳过后续处理"
+            )
+
+        # 对其它交易所进行拉取
+        for platform in platforms:
+            if platform == self.master:
+                continue
+            platform_df = self.query_symbol_line_data(symbol, platform)
+
+            if len(platform_df) < 1440 * self.day_num:
+                self._logger.error(
+                    f"{platform}平台拉取到的{symbol}的K线数据量不足{1440 * self.day_num}条，跳过该交易所数据"
+                )
+                continue
+
+            df_dict[platform] = platform_df
+
+        #  开始计算差异
+        symbol_diffrenence_dict = self.calculate_kline_difference(
+            symbol, master_df, df_dict
+        )
+
+        self._redis.hset(
+            self.redis_key + ":" + self.master.upper(),
+            symbol,
+            json.dumps({k: v.model_dump() for k, v in symbol_diffrenence_dict.items()}),
+        )
+
+    # 计算各个平台的K线差异
+    def calculate_kline_difference(
+        self, symbol: str, master_df: pd.DataFrame, df_dict: dict
+    ):
+        res = {}
+        # 自己也要计算差异
+        master_std = master_df[f"{self.master}_close"].std()
+        master_mean = master_df[f"{self.master}_close"].mean()
+        master_max = master_df[f"{self.master}_close"].max()
+        master_rate_corr = master_df[f"{self.master}_close"].corr(
+            master_df["event_time"]
+        )
+        master_min = master_df[f"{self.master}_close"].min()
+        master_quantile = master_df[f"{self.master}_close"].quantile([0.25, 0.5, 0.75])
+
+        res[self.master] = StatisticsInfo(
+            platform=self.master,
+            std=master_std,
+            mean=master_mean,
+            max=master_max,
+            corr=master_rate_corr,
+            min=master_min,
+            quantile={str(k): float(v) for k, v in master_quantile.to_dict().items()},
+        )
+        for platform, platform_df in df_dict.items():
+            # 合并数据，找出差异
+            merged_df = pd.merge(
+                master_df, platform_df, on=["symbol", "event_time"], how="inner"
+            )
+            # 计算差值
+            merged_df["close_diff"] = (
+                merged_df[f"{self.master}_close"] - merged_df[f"{platform}_close"]
+            )
+            # 标准差
+            close_std = merged_df["close_diff"].std()
+            # 平均值
+            close_mean = merged_df["close_diff"].mean()
+            # 最大值
+            close_max = merged_df["close_diff"].max()
+            # 皮尔逊系数(斜率)
+            close_corr = merged_df["close_diff"].corr(merged_df["event_time"])
+            # 最小值
+            close_min = merged_df["close_diff"].min()
+            # 4分位数
+            close_quantile = merged_df["close_diff"].quantile([0.25, 0.5, 0.75])
+            # self._logger.info(
+            #     f"{self.master}与{platform}平台的{symbol}的K线差异统计: 标准差={close_std}, 平均值={close_mean}, 最大值={close_max}, 最小值={close_min}, 皮尔逊系数={close_corr}, 四分位数={close_quantile.to_dict()}"
+            # )
+            res[platform] = StatisticsInfo(
+                platform=platform,
+                std=close_std,
+                mean=close_mean,
+                max=close_max,
+                corr=close_corr,
+                min=close_min,
+                quantile={str(k): float(v) for k, v in close_quantile.to_dict().items()},
+            )
+
+        return res
+
+    # 拉指定时间指定symbol的k线数据
+    def query_symbol_line_data(self, symbol: str, platform: str):
+        sql_result_df = pd.DataFrame()
+        zero_timestamp_list = self.get_zero_timestamp_list()
+        # 表前缀
+        table_name_prefix = f"kaq_{platform}_futures_kline_history"
+        for ts in zero_timestamp_list:
+            # 先转成周一日期来定表名，因为数据表是按周来分表的
+            date_str = self.get_monday_time(ts)
+            table_name = f"{table_name_prefix}_{date_str}"
+            sql = f"select exchange, symbol, close as {platform}_close, event_time from {table_name} where symbol = '{symbol}' and event_time >= {ts} and event_time < {ts + 86400000} order by event_time desc ;"
+            result = self._mysql.fetch_data(sql)
+            sql_result_df = pd.concat([sql_result_df, result], ignore_index=True)
+
+        return sql_result_df
+
+    # 计算某个时间戳对应的周一日期字符串
+    def get_monday_time(self, timestamp):
+        dt = datetime.datetime.fromtimestamp(timestamp / 1000)
+        monday = dt - datetime.timedelta(days=dt.weekday())
+        monday = monday.replace(hour=0, minute=0, second=0, microsecond=0)
+        return monday.strftime("%Y%m%d")
+
+    # 计算开始到结束时间所有的0时时间戳
+    def get_zero_timestamp_list(self):
+        # 毫秒转日期
+        timestamp_list = []
+        begin_date = datetime.datetime.fromtimestamp(
+            self.begin_timestamp // 1000, datetime.UTC
+        ).date()
+        end_date = datetime.datetime.fromtimestamp(
+            self.end_timestamp // 1000, datetime.UTC
+        ).date()
+        cur = begin_date
+        while cur <= end_date:
+            # 0点时间戳（毫秒）
+            dt = datetime.datetime.combine(
+                cur, datetime.time(0, 0), tzinfo=datetime.UTC
+            )
+            ts = int(dt.timestamp() * 1000)
+            timestamp_list.append(ts)
+            cur += datetime.timedelta(days=1)
+
+        return timestamp_list
+
+
+if __name__ == "__main__":
+    klineStatistics = FuturesKlineHistoryStatistics(
+        1765296000000, 1765382400000, ["BTCUSDT", "ETHUSDT"]
+    )
+    klineStatistics.symbols_statistics()

kaq_quant_common/common/ws_wrapper.py

@@ -0,0 +1,21 @@
+from abc import abstractmethod
+
+from kaq_quant_common.common.monitor_base import MonitorBase
+
+
+# 通用的抽象类，包装一层ws操作
+class WsWrapper(MonitorBase):
+    def __init__(self):
+        super().__init__()
+
+    # stop 就是调用close，ws 更好理解
+    def _do_stop(self):
+        self._do_close()
+
+    # 断开连接，主动关闭
+    def close(self):
+        self.stop()
+
+    @abstractmethod
+    def _do_close(self):
+        pass

kaq_quant_common/config/config.yaml

@@ -0,0 +1,5 @@
+# KAQ 配置
+# 说明：统一鉴权 token。若设置则客户端自动携带，服务端会校验。
+# 生效顺序：环境变量 KAQ_API_TOKEN 优先，其次该文件中的 kaq.api_token。
+kaq:
+  api_token: "change_me_token"

kaq_quant_common/resources/kaq_ddb_pool_stream_read_resources.py

@@ -0,0 +1,56 @@
+import os
+import dolphindb as ddb
+import dolphindb.settings as keys
+from dolphindb.settings import SqlStd
+from kaq_quant_common.utils import yml_utils
+import pandas as pd
+import threading
+from kaq_quant_common.utils.logger_utils import get_logger
+import traceback
+from dolphindb.settings import PROTOCOL_PICKLE
+
+mutex = threading.Lock()
+
+class KaqQuantDdbPoolStreamReadRepository:
+    '''
+    连接池方式连接DolphinDB数据库, 支持流数据表读取
+    '''
+    def __init__(self, host, port, user, passwd, pool_size=1, protocal:keys=PROTOCOL_PICKLE):
+        self.logger = get_logger(self)
+        try:
+            mutex.acquire()
+            
+            # 连接地址为localhost，端口为8848的DolphinDB，登录用户名为admin，密码为123456的账户，连接数为8
+            self.pool = ddb.DBConnectionPool(host, port, pool_size, user, passwd, 
+                                             loadBalance=False, 
+                                             compress=True, 
+                                             protocol=protocal,
+                                             reConnect=True, 
+                                            #  tryReconnectNums=5, # 若不开启高可用，须与 reconnect 参数搭配使用，对单节点进行有限次重连。若不填写该参数，默认进行无限重连。
+                                             sqlStd=SqlStd.DolphinDB
+                                             )
+        except Exception as e:
+            self.logger.error(f'KaqQuantDdbPoolStreamReadRepository.__init__ is occured error: {str(e)} - {str(traceback.format_exc())}')
+        finally:
+            mutex.release()
+    
+    async def query(self, script: str, pickleTableToList=False) -> pd.DataFrame:
+        '''
+        从流数据表中获取数据
+        '''
+        try:
+            data = await self.pool.run(script, pickleTableToList=pickleTableToList, clearMemory=True)
+            if data is None:
+                return pd.DataFrame()
+            big_df = pd.DataFrame(data)
+            return big_df
+        except Exception as e:
+            self.logger.error(f'KaqQuantDdbPoolStreamReadRepository.fetch is occured error: {str(e)} - {str(traceback.format_exc())}')
+        return pd.DataFrame()
+
+
+if __name__ == '__main__':
+    host, port, user, passwd = yml_utils.get_ddb_info(os.getcwd())
+    kaq = KaqQuantDdbPoolStreamReadRepository(host, port, user, passwd)
+    df = kaq.query(f"select count(*) from kaq_all_future_limit_order_streaming")
+    print(df.head(5))

kaq_quant_common/resources/kaq_ddb_stream_init_resources.py

@@ -0,0 +1,88 @@
+import threading
+import traceback
+from string import Template
+
+import dolphindb as ddb
+from kaq_quant_common.utils import yml_utils
+from kaq_quant_common.utils.logger_utils import get_logger
+
+mutex = threading.Lock()
+
+
+class KaqQuantDdbStreamInitRepository:
+    '''
+    定义 asof_join的级联方式, 合并数据到一起, 然后可以订阅判断
+    '''
+
+    def __init__(self, host, port, user, passwd, ddb_script_files={}):
+        self.logger = get_logger(self)
+        if not host or not port or not user or not passwd:
+            self.logger.error("【DDB连接参数错误】请检查配置文件")
+        if not ddb_script_files or len(ddb_script_files) == 0:
+            self.logger.error("【DDB脚本文件列表为空】请检查配置文件")
+
+        mutex.acquire()
+        '''
+        创建ddb连接 && 添加ddb流数据表支持
+        '''
+        self.session = ddb.session(enableASYNC=True)
+        self.session.connect(host, port, user, passwd)
+        # self.session.enableStreaming()
+
+        '''
+        创建流数据表 && 创建引擎
+        '''
+        for script_file, args in ddb_script_files.items():
+            try:
+                # 读取脚本 并转换为gbk编码
+                with open(file=script_file, mode="r", encoding="utf-8") as fp:
+                    script = fp.read().encode('gbk').decode('gbk')
+                if args is None or len(args) == 0:
+                    # self.session.runFile(script_file)
+                    pass
+                else:
+                    template = Template(script)
+                    script = template.substitute(**args)
+                self.session.run(script)
+            except Exception as e:
+                self.logger.error(f"【创建ddb数据流引擎】 {script_file} 错误异常: {str(e)} - {str(traceback.format_exc())}")
+                self.cancel_subscribe()
+        mutex.release()
+
+    def cancel_subscribe(self, file_path=None):
+        # return
+        '''
+        1、取消订阅
+        PS: 此处不能使用python的localhost
+        创建流订阅与引擎
+        使用的是ddb的脚步
+        传输到服务器上运行
+        会调用的节点为服务器ip、port、节点名称
+        '''
+        if file_path is None or file_path == "":
+            self.logger.info("【取消订阅】请传参数file_path")
+            return
+        self.session.runFile(file_path)
+
+    def drop_streaming(self, file_path=None):
+        # return
+        '''
+        1、取消订阅
+        PS: 此处不能使用python的localhost
+        创建流订阅与引擎
+        使用的是ddb的脚步
+        传输到服务器上运行
+        会调用的节点为服务器ip、port、节点名称
+        '''
+        if file_path is None or file_path == "":
+            self.logger.info("【取消订阅】请传参数file_path")
+            return
+        self.session.runFile(file_path)
+
+
+if __name__ == '__main__':
+    host, port, user, passwd = yml_utils.get_ddb_info(pkg_name='kaq_binance_quant')
+    ddb_script_files = ['binance_volume_ddb_script.dos', 'binance_limit_order_ddb_script.dos', 'binance_premium_ddb_script.dos']
+    ddb_script_files = [yml_utils.get_pkg_file(None, x) for x in ddb_script_files]
+    kaq = KaqQuantDdbStreamInitRepository(host, port, user, passwd, ddb_script_files)
+    # kaq.drop_streaming()

kaq_quant_common/resources/kaq_ddb_stream_read_resources.py

@@ -0,0 +1,81 @@
+import os
+import dolphindb as ddb
+from kaq_quant_common.utils import yml_utils
+import pandas as pd
+import threading
+from kaq_quant_common.utils.logger_utils import get_logger
+import traceback
+
+mutex = threading.Lock()
+
+class KaqQuantDdbStreamReadRepository:
+    '''
+    定义 asof_join的级联方式, 合并数据到一起, 然后可以订阅判断
+    '''
+    def __init__(self, host, port, user, passwd):
+        self.logger = get_logger(self)
+        '''
+        创建ddb连接 && 添加ddb流数据表支持
+        '''
+        try:
+            mutex.acquire()
+            # 程序读取的时候 同步读取即可, ddb的异步读取，可以使用订阅的方式来实现
+            self.session = ddb.session(enableASYNC=False)
+            self.session.setTimeout(3600)
+            self.session.connect(host, port, user, passwd, keepAliveTime=240, reconnect=True, tryReconnectNums=10)
+            # self.session.enableStreaming()
+
+            # 需要注意的是 fetchSize 取值不能小于 8192 （记录条数）
+            self.size = 8192
+        except Exception as e:
+            self.logger.error(f'KaqQuantDdbStreamReadRepository.__init__ is occured error: {str(e)} - {str(traceback.format_exc())}')
+        finally:
+            mutex.release()
+
+    def count(self, query: str) -> int:
+        '''
+        获取数量, 再去获取总数据
+        sql语句中必须返回的是 count 字段
+        '''
+        try:
+            number_blocks = self.session.run(query, fetchSize=self.size)
+            number = 0
+            while number_blocks.hasNext():
+                number = number_blocks.read()['count'][0]
+            return number
+        except Exception as e:
+            self.logger.error(f'KaqQuantDdbStreamReadRepository.countStream is occured error: {str(e)} - {str(traceback.format_exc())}')
+        return -1
+
+    def cal_page(self, number: int):
+        page = number / self.size
+        if number % self.size > 0:
+            page = page + 1
+        return int(page)
+
+    def query(self, query: str) -> pd.DataFrame:
+        '''
+        从流数据表中获取数据
+        '''
+        try:
+            block = self.session.run(query, fetchSize=self.size)
+            if block is None:
+                return pd.DataFrame()
+            big_df = pd.DataFrame()
+            while block.hasNext():
+                temp_df = block.read()
+                big_df = pd.concat([big_df, temp_df])
+            big_df = big_df.reset_index()
+            return big_df
+        except Exception as e:
+            self.logger.error(f'KaqQuantDdbStreamReadRepository.getStreamQuery is occured error: {str(e)} - {str(traceback.format_exc())}')
+        return pd.DataFrame()
+
+
+if __name__ == '__main__':
+    host, port, user, passwd = yml_utils.get_ddb_info(os.getcwd())
+    kaq = KaqQuantDdbStreamReadRepository(host, port, user, passwd)
+    # kaq.drop_streaming()
+    count = kaq.countStream(f"select count(*) from kaq_binance_force_order_streaming where symbol == 'FIOUSDT'")
+    df = kaq.getStreamQuery(query=f"select * from kaq_binance_force_order_streaming where symbol == 'FIOUSDT' order by create_time asc")
+    print(df.head(5))