python - 如何缓存我的 SQL 结果，这样我就不必重复调用 SQL 来获取 Dash 图的数据？

Question

我正在尝试构建一个仪表板，该仪表板将根据单个 SQL 数据查询生成多个图。我希望可以通过仪表板修改查询(例如，查询不同的订单金额或类似金额)，然后一次更改所有图表。查询可能很昂贵，所以我不希望它针对 N 个不同的地 block 运行 N 次。

我尝试使用 flask 缓存装饰器 @cache.memoize() 来做到这一点，类似于文档中给出的示例:https://dash.plotly.com/performance

这是我正在做的事情的精简版。我可以看出 query_data 函数没有按照我的意图进行，因为: 1. 结果图在 x 轴上显示不同的数据点。如果它使用相同的缓存数据集，则 x 中的数据点应该相同 2. 每次更改输入单元格时，query_data 函数中的 print 语句都会出现两次。

谁能解释为什么这不起作用或我如何才能实现我想要的。

import sys

import dash
import dash_core_components as dcc
import dash_html_components as html
import plotly.express as px
from dash.dependencies import Input, Output

from setup_redshift import setup_connection
from flask_caching import Cache
from datetime import datetime
import pandas as pd

conn = setup_connection()

app = dash.Dash(__name__)
cache = Cache(app.server, config={
    # 'CACHE_TYPE': 'filesystem',
    'CACHE_TYPE': 'memcached',
    'CACHE_DIR': 'cache-directory'
})

sql_query = '''select i.order_amount_in_usd, r.calibrated_score, r.score
from datalake.investigations i 
inner join datalagoon.prod_model_decision r
                    ON i.investigation_id = r.investigation_id

where i.team_id = {}
AND i.order_amount_in_usd < {}
AND r.calibrated_score >= 0
order by RANDOM()
limit 1000'''


@cache.memoize()
def query_data(team_id, max_usd):
    print("Calling data query now with team_id={} and max_usd={} at time {}".format(team_id, max_usd, datetime.now()))
    _sql = sql_query.format(team_id, max_usd)
    print(_sql)
    data = pd.read_sql(sql_query.format(team_id, max_usd), conn)
    print("data is {} rows ".format(len(data)))
    print("data max usd is {}".format(data['order_amount_in_usd'].max()))
    return data


@app.callback(Output(component_id='output-graph', component_property='figure'),
              [Input(component_id='data-select-team-id', component_property='value'),
               Input(component_id='data-select-max-usd', component_property='value')])
def plot_data(team_id, max_usd):
    print("calling query_data at from graph at {}".format(datetime.now()))
    in_data = query_data(team_id, max_usd)
    print("going to make graph1 now at {}".format(datetime.now()))

    fig = px.scatter(in_data,
                     x='order_amount_in_usd',
                     y='calibrated_score')
    return fig


@app.callback(Output(component_id='output-graph2', component_property='figure'),
              [Input(component_id='data-select-team-id', component_property='value'),
               Input(component_id='data-select-max-usd', component_property='value')])
def plot_second_data(team_id, max_usd):
    print("calling query_data at from graph2 at {}".format(datetime.now()))
    in_data = query_data(team_id, max_usd)
    print("going to make graph2 now at {}".format(datetime.now()))
    fig = px.scatter(in_data,
                     x='order_amount_in_usd',
                     y='score')
    return fig


app.layout = html.Div(  # style={'backgroundColor': colors['background']},

    children=[dcc.Input(id='data-select-team-id',
                        value=7625,
                        placeholder='Input Team ID',
                        type='number',
                        min=0,
                        max=1_000_000_000,
                        debounce=True
                        ),
              dcc.Input(id='data-select-max-usd',
                        value=5000,
                        type='number',
                        debounce=True),
              dcc.Graph(id='output-graph'),
              dcc.Graph(id='output-graph2')]
)

if __name__ == '__main__':
    app.run_server(debug=True)

Answer 1

过去我使用 dcc.Store 存储结果(参见 here )

您可以像这样构建您的应用:

• 运行 SQL 查询并使用 dcc.Store(本地或内存取决于您的用例)。这只运行一次(每次应用加载、间隔计时器或用户按钮刷新等)
• 回调生成不同的切割破折号表或图表中的数据会加载商店

如果查询结果很大(请参阅上面链接中的“存储限制”)，那么您应该将结果保存到本地平面文件(例如 JSON 或 CSV)中，并每次都读取它。

另一种方法是使用 PostgreSQL 和物化 View 来降低 SQL 查询的成本(以牺牲存储空间为代价)

这些方法使 dash 应用程序看起来对用户非常敏感，同时允许分析大数据