Understanding reactive functions in Shiny

Question

I have created a Shiny app which pulls in data from a database. I have a number of inputs in the UI part, and a number of outputs in the Server part.

In the server part I have a reactive function that builds a query using some of the inputs and then pulls in data from a database, eg:

queriedData <- reactive({
                query <- paste0(...,input$a,...);
                return(db$find(query))
               })

In the output slots, I refer to the data in using

x <- queriedData()

My questions are:

• I believe the database is polled only when inputs that are referred to in the reactive function change. Is this correct?
• As a consequence, am I correct in thinking that calling this reactive function does not spawn a query - ie the data is cached and the cached data is provided?
• For inputs that are not part of the query, I am assuming changes to these do not cause a new database query. Is this correct?

Answer 1

To answer your questions:

1. Indeed, any reactive expression is only revalidated when one of the reactive expressions it depend on it is updated. Shiny does this to pass an invalidate flag whenever a value of a reactive expression changes to all other reactive expressions that depend on it. The next time these invalidated reactive expressions are used, they are recalculated. So in your case queriedData (which is a reactive expression) will be invalidated and hence updated every time it receives an invalidate flag from input$a. As the data base query is part of that calculation, your assumption is correct.
2. That depends. When input$a didn't change and hence queriedData is not invalidated, it just returns the cached data. When input$a did change however, queriedData is recalculated and hence will spawn a query.
3. As only reactive expressions can pass an invalidate flag, those are the only ones that can actually cause another reactive expression to be recalculated. If other parts are not reactive, they also can't invalidate and hence can't cause a recalculation of queriedData.

Keep in mind that a reactive expression doesn't necessarily need to be an input. Take following example:

query <- reactive({paste0(...,input$a,...)})
queriedData <- reactive({
                db$find(query())
               })
output$thedata <- renderDataTable(queriedData())

Now a change in input$a will invalidate query, triggering its recalculation. query, a reactive expression, will invalidate queriedData(), triggering its recalculation. This will invalidate output$thedata, and hence cause also that part to be recalculated, resulting in the new data shown in the data table.