From b79b71e20be8c3d6f092b0e671e50f56776488e8 Mon Sep 17 00:00:00 2001 From: Carson Date: Fri, 1 May 2026 15:08:36 -0500 Subject: [PATCH 1/4] feat(pkg-r): add ggsql integration --- js/build.mjs | 13 +- pkg-r/DESCRIPTION | 9 +- pkg-r/R/QueryChat.R | 43 +- pkg-r/R/QueryChatSystemPrompt.R | 16 +- pkg-r/R/querychat_module.R | 53 +- pkg-r/R/querychat_tools.R | 22 +- pkg-r/R/querychat_viz.R | 383 ++++++++++++ pkg-r/inst/examples-shiny/10-viz-app/app.R | 32 + pkg-r/inst/htmldep/viz.css | 150 +++++ pkg-r/inst/htmldep/viz.js | 166 ++++++ pkg-r/inst/prompts/ggsql-syntax.md | 553 ++++++++++++++++++ pkg-r/inst/prompts/prompt.md | 94 ++- pkg-r/inst/prompts/tool-query.md | 16 +- pkg-r/inst/prompts/tool-visualize.md | 23 + pkg-r/man/QueryChat.Rd | 13 +- pkg-r/man/execute_ggsql.Rd | 22 + pkg-r/man/extract_visualise_table.Rd | 19 + pkg-r/man/has_layer_level_source.Rd | 20 + pkg-r/tests/testthat/test-QueryChat.R | 63 ++ .../testthat/test-QueryChatSystemPrompt.R | 77 +++ pkg-r/tests/testthat/test-collapsed-param.R | 56 ++ pkg-r/tests/testthat/test-querychat-viz.R | 141 +++++ pkg-r/tests/testthat/test-querychat_module.R | 113 ++++ pkg-r/tests/testthat/test-viz-tool.R | 437 ++++++++++++++ 24 files changed, 2513 insertions(+), 21 deletions(-) create mode 100644 pkg-r/R/querychat_viz.R create mode 100644 pkg-r/inst/examples-shiny/10-viz-app/app.R create mode 100644 pkg-r/inst/htmldep/viz.css create mode 100644 pkg-r/inst/htmldep/viz.js create mode 100644 pkg-r/inst/prompts/ggsql-syntax.md create mode 100644 pkg-r/inst/prompts/tool-visualize.md create mode 100644 pkg-r/man/execute_ggsql.Rd create mode 100644 pkg-r/man/extract_visualise_table.Rd create mode 100644 pkg-r/man/has_layer_level_source.Rd create mode 100644 pkg-r/tests/testthat/test-collapsed-param.R create mode 100644 pkg-r/tests/testthat/test-querychat-viz.R create mode 100644 pkg-r/tests/testthat/test-viz-tool.R diff --git a/js/build.mjs b/js/build.mjs index a07f83844..6b95400d0 100644 --- a/js/build.mjs +++ b/js/build.mjs @@ -20,6 +20,10 @@ const jsTargets = [ source: "src/viz.ts", output: "../pkg-py/src/querychat/static/js/viz.js", }, + { + source: "src/viz.ts", + output: "../pkg-r/inst/htmldep/viz.js", + }, ]; const cssTargets = [ @@ -27,6 +31,10 @@ const cssTargets = [ source: "src/viz.css", output: "../pkg-py/src/querychat/static/css/viz.css", }, + { + source: "src/viz.css", + output: "../pkg-r/inst/htmldep/viz.css", + }, ]; const ensureParentDir = async (relativePath) => { @@ -81,10 +89,9 @@ const reportMissingSources = async () => { }; export const stageBuildOutputs = async (stageDir) => { - const cssSourcePath = path.resolve(rootDir, "src/viz.css"); - const cssSource = await readFile(cssSourcePath, "utf8"); - for (const target of cssTargets) { + const cssSourcePath = path.resolve(rootDir, target.source); + const cssSource = await readFile(cssSourcePath, "utf8"); const outputPath = resolveOutputPath(stageDir, target.output); await mkdir(path.dirname(outputPath), { recursive: true }); await writeFile(outputPath, `${banner(target.source)}${cssSource}`, "utf8"); diff --git a/pkg-r/DESCRIPTION b/pkg-r/DESCRIPTION index 532a055ec..7887a096b 100644 --- a/pkg-r/DESCRIPTION +++ b/pkg-r/DESCRIPTION @@ -22,7 +22,8 @@ BugReports: https://github.com/posit-dev/querychat/issues Depends: R (>= 4.1.0) Imports: - bslib, + bsicons, + bslib (>= 0.10.0), cli, DBI, ellmer (>= 0.3.0), @@ -37,20 +38,24 @@ Imports: utils, whisker Suggests: - bsicons, dbplyr, dplyr, DT, duckdb, + ggsql, knitr, palmerpenguins, rmarkdown, RSQLite, + rsvg, shinytest2, testthat (>= 3.0.0), + V8, withr VignetteBuilder: knitr +Remotes: + posit-dev/ggsql-r Config/testthat/edition: 3 Config/testthat/parallel: true Encoding: UTF-8 diff --git a/pkg-r/R/QueryChat.R b/pkg-r/R/QueryChat.R index a471c4dd2..7a9987c15 100644 --- a/pkg-r/R/QueryChat.R +++ b/pkg-r/R/QueryChat.R @@ -137,8 +137,10 @@ QueryChat <- R6::R6Class( create_session_client = function( client_spec = NULL, tools = NA, + session = NULL, update_dashboard = function(query, title) {}, - reset_dashboard = function() {} + reset_dashboard = function() {}, + visualize = function(data) {} ) { spec <- client_spec %||% private$.client_spec chat <- as_querychat_client(spec) @@ -169,6 +171,21 @@ QueryChat <- R6::R6Class( chat$register_tool(tool_query(private$.data_source)) } + if ("visualize" %in% tools) { + rlang::check_installed( + "ggsql", + reason = "for visualization support." + ) + chat$register_tool( + tool_visualize_dashboard( + private$.data_source, + session = session, + update_fn = visualize, + has_tool_query = "query" %in% tools + ) + ) + } + chat } ), @@ -249,7 +266,11 @@ QueryChat <- R6::R6Class( # Validate arguments check_string(id, allow_null = TRUE) check_string(greeting, allow_null = TRUE) - arg_match(tools) + arg_match( + tools, + values = c("update", "query", "visualize"), + multiple = TRUE + ) check_string(data_description, allow_null = TRUE) check_number_whole(categorical_threshold, min = 1) check_string(extra_instructions, allow_null = TRUE) @@ -318,25 +339,35 @@ QueryChat <- R6::R6Class( #' `title` generated by the LLM for the `update_dashboard` tool. #' @param reset_dashboard Optional function to call when the #' `reset_dashboard` tool is called. + #' @param visualize Optional function to call with a list containing + #' `ggsql`, `title`, and `widget_id` when a visualization succeeds. + #' @param session A Shiny session object. Required when `"visualize"` is + #' in `tools` and you want interactive chart rendering. When `NULL` + #' (the default), visualizations still execute but are not rendered + #' as Shiny outputs. client = function( tools = NA, update_dashboard = function(query, title) {}, - reset_dashboard = function() {} + reset_dashboard = function() {}, + visualize = function(data) {}, + session = NULL ) { private$require_data_source("$client") if (!is_na(tools) && !is.null(tools)) { tools <- arg_match( tools, - values = c("update", "query"), + values = c("update", "query", "visualize"), multiple = TRUE ) } private$create_session_client( tools = tools, + session = session, update_dashboard = update_dashboard, - reset_dashboard = reset_dashboard + reset_dashboard = reset_dashboard, + visualize = visualize ) }, @@ -417,7 +448,6 @@ QueryChat <- R6::R6Class( app_obj = function(..., bookmark_store = "url") { private$require_data_source("$app_obj") check_installed("DT") - check_installed("bsicons") check_dots_empty() table_name <- private$.data_source$table_name @@ -705,6 +735,7 @@ QueryChat <- R6::R6Class( data_source = private$.data_source, greeting = self$greeting, client = create_session_client, + tools = self$tools, enable_bookmarking = enable_bookmarking ) }, diff --git a/pkg-r/R/QueryChatSystemPrompt.R b/pkg-r/R/QueryChatSystemPrompt.R index 694355075..ba11d454b 100644 --- a/pkg-r/R/QueryChatSystemPrompt.R +++ b/pkg-r/R/QueryChatSystemPrompt.R @@ -101,10 +101,24 @@ QueryChatSystemPrompt <- R6::R6Class( extra_instructions = self$extra_instructions, has_tool_update = if ("update" %in% tools) "true", has_tool_query = if ("query" %in% tools) "true", + has_tool_visualize = if ("visualize" %in% tools) "true", include_query_guidelines = if (length(tools) > 0) "true" ) - whisker::whisker.render(self$template, context) + partials <- list() + syntax_path <- system.file( + "prompts", + "ggsql-syntax.md", + package = "querychat" + ) + if (nzchar(syntax_path)) { + partials[["ggsql-syntax"]] <- paste( + readLines(syntax_path), + collapse = "\n" + ) + } + + whisker::whisker.render(self$template, context, partials = partials) } ) ) diff --git a/pkg-r/R/querychat_module.R b/pkg-r/R/querychat_module.R index ead9774b1..a851035ba 100644 --- a/pkg-r/R/querychat_module.R +++ b/pkg-r/R/querychat_module.R @@ -25,6 +25,7 @@ mod_server <- function( data_source, greeting, client, + tools = c("update", "query"), enable_bookmarking = FALSE ) { shiny::moduleServer(id, function(input, output, session) { @@ -61,11 +62,24 @@ mod_server <- function( querychat_tool_result(action = "reset") } + # Non-reactive bookkeeping for bookmark save/restore of viz widgets + viz_widgets <- list() + + on_visualize <- function(data) { + viz_widgets[[length(viz_widgets) + 1L]] <<- list( + widget_id = data$widget_id, + ggsql = data$ggsql + ) + } + # Set up the chat object for this session check_function(client) chat <- client( update_dashboard = update_dashboard, - reset_dashboard = reset_query + reset_dashboard = reset_query, + visualize = on_visualize, + tools = tools, + session = session ) # Prepopulate the chat UI with a welcome message that appears to be from the @@ -121,6 +135,9 @@ mod_server <- function( state$values$querychat_sql <- current_query() state$values$querychat_title <- current_title() state$values$querychat_has_greeted <- has_greeted() + if (length(viz_widgets) > 0) { + state$values$querychat_viz_widgets <- viz_widgets + } }) shiny::onRestore(function(state) { @@ -133,6 +150,14 @@ mod_server <- function( if (!is.null(state$values$querychat_has_greeted)) { has_greeted(state$values$querychat_has_greeted) } + if (!is.null(state$values$querychat_viz_widgets)) { + restored <- restore_viz_widgets( + data_source, + state$values$querychat_viz_widgets, + session + ) + viz_widgets <<- restored + } }) } @@ -147,3 +172,29 @@ mod_server <- function( # TODO: Make this dependent on enabled tools GREETING_PROMPT <- "Please give me a friendly greeting. Include a few sample prompts in a two-level bulleted list." + +restore_viz_widgets <- function(data_source, saved_widgets, session) { + rlang::check_installed("ggsql", reason = "for visualization support.") + + restored <- list() + for (entry in saved_widgets) { + tryCatch( + { + validated <- ggsql::ggsql_validate(entry$ggsql) + spec <- execute_ggsql(data_source, validated) + session$output[[entry$widget_id]] <- ggsql::renderGgsql(spec) + restored <- c(restored, list(entry)) + }, + error = function(e) { + warning( + sprintf( + "Failed to restore visualization widget '%s' on bookmark restore.", + entry$widget_id + ), + call. = FALSE + ) + } + ) + } + restored +} diff --git a/pkg-r/R/querychat_tools.R b/pkg-r/R/querychat_tools.R index 60e99af9c..03f33216a 100644 --- a/pkg-r/R/querychat_tools.R +++ b/pkg-r/R/querychat_tools.R @@ -92,8 +92,13 @@ tool_query <- function(data_source) { db_type <- data_source$get_db_type() ellmer::tool( - function(query, `_intent` = "") { - querychat_tool_result(data_source, query, action = "query") + function(query, `_intent` = "", collapsed = FALSE) { + querychat_tool_result( + data_source, + query, + action = "query", + collapsed = collapsed + ) }, name = "querychat_query", description = interpolate_package("tool-query.md", db_type = db_type), @@ -106,6 +111,10 @@ tool_query <- function(data_source) { ), `_intent` = ellmer::type_string( "A brief, user-friendly description of what this query calculates or retrieves." + ), + collapsed = ellmer::type_boolean( + "Optional (default: false). Set to true for exploratory or preparatory queries whose results aren't the primary answer. When true, the result card starts collapsed.", + required = FALSE ) ), annotations = ellmer::tool_annotations( @@ -161,7 +170,8 @@ querychat_tool_result <- function( data_source, query, title = NULL, - action = "update" + action = "update", + collapsed = NULL ) { action <- arg_match(action, c("update", "query", "reset")) @@ -231,7 +241,11 @@ querychat_tool_result <- function( title = if (action == "update" && !is.null(title)) title, show_request = is_error, markdown = display_md, - open = querychat_tool_starts_open(action) + open = if (!is.null(collapsed)) { + !collapsed + } else { + querychat_tool_starts_open(action) + } ) ) ) diff --git a/pkg-r/R/querychat_viz.R b/pkg-r/R/querychat_viz.R new file mode 100644 index 000000000..4ae560ef1 --- /dev/null +++ b/pkg-r/R/querychat_viz.R @@ -0,0 +1,383 @@ +tool_visualize_dashboard <- function( + data_source, + session, + update_fn = function(data) {}, + has_tool_query = FALSE +) { + check_data_source(data_source) + check_function(update_fn) + + db_type <- data_source$get_db_type() + + ellmer::tool( + tool_visualize_impl(data_source, session, update_fn), + name = "querychat_visualize", + description = render_viz_tool_description( + db_type = db_type, + has_tool_query = has_tool_query + ), + arguments = list( + ggsql = ellmer::type_string( + ellmer::interpolate( + "A full ggsql query. Must include a VISUALISE clause and at least one DRAW clause. The SELECT portion uses {{db_type}} SQL; VISUALISE and MAPPING accept column names only, not expressions. Do NOT include `LABEL title => ...` in the query — use the `title` parameter instead.", + db_type = db_type + ) + ), + title = ellmer::type_string( + "A brief, user-friendly title for this visualization. This is displayed as the card header above the chart." + ) + ), + annotations = ellmer::tool_annotations( + title = "Query Visualization", + icon = viz_icon() + ) + ) +} + +tool_visualize_impl <- function(data_source, session, update_fn) { + force(data_source) + force(session) + force(update_fn) + + function(ggsql, title) { + visualize_result(data_source, session, update_fn, ggsql, title) + } +} + +visualize_result <- function( + data_source, + session, + update_fn, + ggsql_str, + title +) { + rlang::check_installed("ggsql", reason = "for visualization support.") + + validated <- ggsql::ggsql_validate(ggsql_str) + has_visual <- ggsql::ggsql_has_visual(validated) + + if (!has_visual) { + rlang::abort( + "Query must include a VISUALISE clause. Use querychat_query for queries without visualization." + ) + } + + if (!isTRUE(validated$valid)) { + rlang::abort(collapse_validation_errors(validated)) + } + + spec <- execute_ggsql(data_source, validated) + + widget_id <- paste0( + "querychat_viz_", + format(as.hexmode(sample.int(.Machine$integer.max, 1)), width = 8) + ) + + viz_container <- NULL + if (!is.null(session)) { + session$output[[widget_id]] <- ggsql::renderGgsql(spec) + viz_container <- htmltools::div( + class = "querychat-viz-container", + ggsql::ggsqlOutput(session$ns(widget_id)), + viz_dep() + ) + } else { + # Non-Shiny usage: print the Spec to display via the interactive viewer + print(spec) + update_fn(list(ggsql = ggsql_str, title = title, widget_id = widget_id)) + return(ellmer::ContentToolResult( + value = sprintf( + "Chart displayed%s.", + if (nzchar(title)) sprintf(" with title '%s'", title) else "" + ) + )) + } + + # PNG snapshot for LLM feedback (best-effort; requires V8 + rsvg) + png_file <- tempfile(fileext = ".png") + on.exit(unlink(png_file), add = TRUE) + png_content <- tryCatch( + { + ggsql::ggsql_save(spec, png_file, width = 500, height = 300) + ellmer::content_image_file(png_file) + }, + error = function(e) { + cli::cli_warn(c( + "Unable to render PNG preview for the visualization card.", + "i" = "The interactive chart will still render, but the LLM will not receive the static image preview for this visualization.", + "i" = "PNG preview generation requires optional dependencies used by {.fn ggsql::ggsql_save}, typically {.pkg V8} and {.pkg rsvg}.", + "x" = "Underlying error: {.msg {conditionMessage(e)}}" + )) + NULL + } + ) + + title_display <- if (nzchar(title)) { + sprintf(" with title '%s'", title) + } else { + "" + } + text <- sprintf("Chart displayed%s.", title_display) + + # All list elements must be Content S7 objects for ellmer's + # expand_content_if_needed() to handle mixed text+image results. + value <- if (!is.null(png_content)) { + list(ellmer::ContentText(text), png_content) + } else { + text + } + + update_fn(list(ggsql = ggsql_str, title = title, widget_id = widget_id)) + + footer <- build_viz_footer( + ggsql_str, + title, + widget_id, + dom_widget_id = session$ns(widget_id) + ) + extra <- list( + display = list( + html = viz_container, + title = if (nzchar(title)) title else "Query Visualization", + show_request = FALSE, + open = querychat_tool_starts_open("visualize"), + full_screen = TRUE, + icon = viz_icon(), + footer = footer + ) + ) + + ellmer::ContentToolResult(value = value, extra = extra) +} + +collapse_validation_errors <- function(validated) { + errors <- validated$errors + if (is.null(errors) || !nrow(errors)) { + return("Invalid ggsql query.") + } + + messages <- errors$message + messages <- messages[!is.na(messages) & nzchar(messages)] + if (!length(messages)) { + return("Invalid ggsql query.") + } + + paste(messages, collapse = "\n") +} + +build_viz_footer <- function( + ggsql_str, + title, + widget_id, + dom_widget_id +) { + footer_id <- paste0( + "querychat_footer_", + format(as.hexmode(sample.int(.Machine$integer.max, 1)), width = 8) + ) + query_section_id <- paste0(footer_id, "_query") + code_editor_id <- paste0(footer_id, "_code") + + code_editor <- bslib::input_code_editor( + id = code_editor_id, + value = ggsql_str, + # TODO: require bslib>0.10 for ggsql language support, then switch to "ggsql" here + language = if (packageVersion("bslib") > "0.10") "ggsql" else "sql", + read_only = TRUE, + line_numbers = FALSE, + height = "auto", + theme_dark = "github-dark" + ) + + query_section <- shiny::tags$div( + class = "querychat-query-section", + id = query_section_id, + code_editor + ) + + buttons_row <- shiny::tags$div( + class = "querychat-footer-buttons", + # Left: Show Query toggle + shiny::tags$div( + class = "querychat-footer-left", + shiny::tags$button( + class = "querychat-show-query-btn", + `data-querychat-action` = "show-query", + `data-target` = query_section_id, + shiny::tags$span(class = "querychat-query-chevron", "\u25b6"), + shiny::tags$span(class = "querychat-query-label", "Show Query") + ) + ), + # Right: Save dropdown + shiny::tags$div( + class = "querychat-footer-right", + shiny::tags$div( + class = "querychat-save-dropdown", + shiny::tags$button( + class = "querychat-save-btn", + `data-querychat-action` = "save-toggle", + `data-widget-id` = dom_widget_id, + bsicons::bs_icon("download", class = "querychat-icon"), + "Save", + bsicons::bs_icon("chevron-down", class = "querychat-dropdown-chevron") + ), + shiny::tags$div( + class = "querychat-save-menu", + shiny::tags$button( + class = "querychat-save-png-btn", + `data-querychat-action` = "save-png", + `data-widget-id` = dom_widget_id, + `data-title` = title, + "Save as PNG" + ), + shiny::tags$button( + class = "querychat-save-svg-btn", + `data-querychat-action` = "save-svg", + `data-widget-id` = dom_widget_id, + `data-title` = title, + "Save as SVG" + ) + ) + ) + ) + ) + + htmltools::tagList(buttons_row, query_section) +} + +viz_icon <- function() { + '' +} + +viz_dep <- function() { + htmltools::htmlDependency( + name = "querychat-viz", + version = utils::packageVersion("querychat"), + package = "querychat", + src = "htmldep", + stylesheet = "viz.css", + script = "viz.js" + ) +} + +render_viz_tool_description <- function(db_type, has_tool_query = FALSE) { + path <- system.file("prompts", "tool-visualize.md", package = "querychat") + stopifnot(nzchar(path), file.exists(path)) + template <- paste(readLines(path, warn = FALSE), collapse = "\n") + whisker::whisker.render( + template, + list( + db_type = db_type, + has_tool_query = if (isTRUE(has_tool_query)) "true" + ) + ) +} + +#' Execute a pre-validated ggsql query against a DataSource +#' +#' Executes the SQL portion through a DataSource (preserving database pushdown), +#' then feeds the result into a ggsql DuckDB reader to produce a Spec. +#' +#' @param data_source A querychat DataSource R6 object. +#' @param validated A pre-validated ggsql query (from `ggsql::ggsql_validate()`). +#' Must be a list with `$sql` and `$visual` fields. +#' +#' @return A `ggsql::Spec` R6 object (the writer-independent plot specification). +#' +#' @keywords internal +execute_ggsql <- function(data_source, validated) { + rlang::check_installed("ggsql", reason = "for visualization support.") + + visual <- validated$visual + + if (has_layer_level_source(visual)) { + cli::cli_abort( + "Layer-specific sources are not currently supported in querychat visual queries. Rewrite the query so that all layers come from the final SQL result." + ) + } + + df <- data_source$execute_query(validated$sql) + + reader <- ggsql::duckdb_reader() + table <- extract_visualise_table(visual) + + if (!is.null(table)) { + # VISUALISE [mappings] FROM — register data under the + # referenced table name and execute the visual part directly. + name <- if (startsWith(table, '"') && endsWith(table, '"')) { + substr(table, 2, nchar(table) - 1) + } else { + table + } + ggsql::ggsql_register(reader, df, name) + ggsql::ggsql_execute(reader, visual) + } else { + # SELECT ... VISUALISE — no FROM in VISUALISE clause, so register + # under a synthetic name and prepend a SELECT. + ggsql::ggsql_register(reader, df, "_data") + ggsql::ggsql_execute(reader, paste("SELECT * FROM _data", visual)) + } +} + +#' Extract the table name from a VISUALISE clause's FROM, if present +#' +#' Looks only in the portion of the visual string before the first DRAW keyword, +#' so FROM clauses inside DRAW (e.g., MAPPING x FROM other) are ignored. +#' +#' @param visual A ggsql VISUALISE string. +#' @return The table name string (possibly quoted), or `NULL` if not present. +#' +#' @keywords internal +extract_visualise_table <- function(visual) { + draw_pos <- regexpr("\\bDRAW\\b", visual, ignore.case = TRUE, perl = TRUE) + vis_clause <- if (draw_pos > 0) substr(visual, 1, draw_pos - 1L) else visual + m <- regmatches( + vis_clause, + regexpr( + '\\bFROM\\s+("[^"]+?"|\\S+)', + vis_clause, + ignore.case = TRUE, + perl = TRUE + ) + ) + if (length(m) == 0 || !nzchar(m)) { + return(NULL) + } + sub("^(?i)FROM\\s+", "", m, perl = TRUE) +} + +#' Detect whether a VISUALISE string has a layer-level FROM source +#' +#' Returns `TRUE` when a DRAW clause defines its own `FROM ` via a +#' MAPPING sub-clause. Querychat replays VISUALISE against a single local +#' relation, so layer-specific sources cannot be preserved reliably. +#' +#' @param visual A ggsql VISUALISE string. +#' @return `TRUE` if any DRAW clause contains a MAPPING ... FROM source. +#' +#' @keywords internal +has_layer_level_source <- function(visual) { + # Split at clause boundaries (DRAW, SCALE, etc.) using a lookbehind for + # whitespace rather than \b, which can split mid-word in R's PCRE engine. + clauses <- strsplit( + visual, + "(?i)(?<=\\s)(?=DRAW|SCALE|PROJECT|FACET|PLACE|LABEL|THEME)", + perl = TRUE + )[[1]] + for (clause in clauses) { + if (!grepl("^\\s*DRAW\\b", clause, ignore.case = TRUE, perl = TRUE)) { + next + } + if ( + grepl( + "\\bMAPPING\\b[\\s\\S]*?\\bFROM\\s+(\"[^\"]+?\"|\\S+)", + clause, + ignore.case = TRUE, + perl = TRUE + ) + ) { + return(TRUE) + } + } + FALSE +} diff --git a/pkg-r/inst/examples-shiny/10-viz-app/app.R b/pkg-r/inst/examples-shiny/10-viz-app/app.R new file mode 100644 index 000000000..fbed89e73 --- /dev/null +++ b/pkg-r/inst/examples-shiny/10-viz-app/app.R @@ -0,0 +1,32 @@ +library(shiny) +library(bslib) +library(querychat) +library(palmerpenguins) + +qc <- QueryChat$new( + penguins, + tools = c("update", "query", "visualize"), + data_description = paste( + "The Palmer Penguins dataset contains measurements of bill", + "dimensions, flipper length, body mass, sex, and species", + "(Adelie, Chinstrap, and Gentoo) collected from three islands in", + "the Palmer Archipelago, Antarctica." + ) +) + +ui <- page_sidebar( + title = "querychat viz demo", + sidebar = qc$sidebar(width = 400, open = TRUE, position = "right"), + card( + full_screen = TRUE, + card_header("Data"), + DT::DTOutput("dt") + ) +) + +server <- function(input, output, session) { + qc_vals <- qc$server() + output$dt <- DT::renderDT(qc_vals$df(), fillContainer = TRUE) +} + +shinyApp(ui, server) diff --git a/pkg-r/inst/htmldep/viz.css b/pkg-r/inst/htmldep/viz.css new file mode 100644 index 000000000..bbf54e6e6 --- /dev/null +++ b/pkg-r/inst/htmldep/viz.css @@ -0,0 +1,150 @@ +/* Generated file. Source: js/src/viz.css. Do not edit directly. */ +/* Hide Vega's built-in action dropdown (we have our own save button) */ +.querychat-viz-container details:has(> .vega-actions) { + display: none !important; +} + +/* ---- Visualization container ---- */ + +.querychat-viz-container { + aspect-ratio: 4 / 2; + width: 100%; +} + +/* In full-screen mode, let the chart fill the available space */ +.shiny-tool-card[fullscreen] .querychat-viz-container { + aspect-ratio: unset; +} + +/* ---- Visualization footer ---- */ + +.querychat-footer-buttons { + display: flex; + justify-content: space-between; + align-items: center; +} + +.querychat-footer-left, +.querychat-footer-right { + display: flex; + align-items: center; + gap: 4px; +} + +.querychat-show-query-btn, +.querychat-save-btn { + display: inline-flex; + align-items: center; + gap: 4px; + padding: 2px 8px; + height: 28px; + border: none; + border-radius: var(--bs-border-radius, 4px); + background: transparent; + color: var(--bs-secondary-color, #6c757d); + font-size: 0.75rem; + cursor: pointer; + white-space: nowrap; +} + +.querychat-show-query-btn:hover, +.querychat-save-btn:hover { + color: var(--bs-body-color, #212529); + background-color: rgba(var(--bs-emphasis-color-rgb, 0, 0, 0), 0.05); +} + +.querychat-query-chevron { + font-size: 0.625rem; + transition: transform 150ms; + display: inline-block; +} + +.querychat-query-chevron--expanded { + transform: rotate(90deg); +} + +.querychat-icon { + width: 14px; + height: 14px; +} + +.querychat-dropdown-chevron { + width: 12px; + height: 12px; + margin-left: 2px; +} + +.querychat-save-dropdown { + position: relative; +} + +.querychat-save-menu { + display: none; + position: absolute; + right: 0; + bottom: 100%; + margin-bottom: 4px; + z-index: 20; + background: var(--bs-body-bg, #fff); + border: 1px solid var(--bs-border-color, #dee2e6); + border-radius: var(--bs-border-radius, 4px); + box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15); + padding: 4px 0; + min-width: 120px; +} + +.querychat-save-menu--visible { + display: block; +} + +.querychat-save-menu button { + display: block; + width: 100%; + padding: 6px 12px; + border: none; + background: transparent; + color: var(--bs-body-color, #212529); + font-size: 0.75rem; + text-align: left; + cursor: pointer; +} + +.querychat-save-menu button:hover { + background-color: rgba(var(--bs-emphasis-color-rgb, 0, 0, 0), 0.05); +} + +.querychat-query-section { + display: none; + position: relative; + border-top: 1px solid var(--bs-border-color, #dee2e6); + margin: 8px -16px -8px; +} + +.querychat-query-section--visible { + display: block; +} + + +/* shinychat sets max-height:500px on all cards, which is too small for viz+editor */ +.shiny-tool-card:has(.querychat-viz-container) { + max-height: 700px; + overflow: hidden; +} + +.shiny-tool-card:has(.querychat-viz-container) > .card-footer { + flex: 0 0 auto; +} + +.shiny-tool-card[fullscreen]:has(.querychat-viz-container) { + max-height: none; +} + +.querychat-query-section bslib-code-editor .code-editor { + margin: 1em; +} + +.querychat-query-section bslib-code-editor .prism-code-editor { + background-color: var(--bs-light, #f8f8f8); + max-height: 200px; + overflow-y: auto; +} diff --git a/pkg-r/inst/htmldep/viz.js b/pkg-r/inst/htmldep/viz.js new file mode 100644 index 000000000..4721c158b --- /dev/null +++ b/pkg-r/inst/htmldep/viz.js @@ -0,0 +1,166 @@ +/* Generated file. Source: js/src/viz.ts. Do not edit directly. */ + +"use strict"; +(() => { + // src/viz-core.ts + function findWidgetContainer(widgetId) { + return document.getElementById(widgetId); + } + function findVegaAction(container, format) { + return container.querySelector( + `.vega-actions a[download$=".${format}"]` + ); + } + function triggerVegaAction(link, filename) { + link.download = filename; + if (link.href && link.href !== "#" && !link.href.endsWith("#")) { + link.click(); + return; + } + const observer = new MutationObserver(() => { + if (link.href && link.href !== "#" && !link.href.endsWith("#")) { + observer.disconnect(); + clearTimeout(timeoutId); + link.click(); + } + }); + observer.observe(link, { + attributes: true, + attributeFilter: ["href"] + }); + const timeoutId = window.setTimeout(() => { + observer.disconnect(); + console.error("Timed out waiting for vega-embed to generate image"); + }, 5e3); + link.dispatchEvent(new MouseEvent("mousedown", { bubbles: true })); + } + var openSaveMenu = null; + function closeSaveMenu(menu) { + menu.classList.remove("querychat-save-menu--visible"); + if (openSaveMenu === menu) { + openSaveMenu = null; + } + } + function closeOpenSaveMenu() { + if (openSaveMenu) { + closeSaveMenu(openSaveMenu); + } + } + function handleShowQuery(event, button) { + event.stopPropagation(); + const targetId = button.dataset.target; + if (!targetId) { + return; + } + const section = document.getElementById(targetId); + if (!section) { + return; + } + const isVisible = section.classList.toggle("querychat-query-section--visible"); + const label = button.querySelector(".querychat-query-label"); + const chevron = button.querySelector(".querychat-query-chevron"); + if (label) { + label.textContent = isVisible ? "Hide Query" : "Show Query"; + } + if (chevron) { + chevron.classList.toggle("querychat-query-chevron--expanded", isVisible); + } + } + function handleSaveToggle(event, button) { + event.stopPropagation(); + const menu = button.parentElement?.querySelector( + ".querychat-save-menu" + ); + if (!menu) { + return; + } + if (openSaveMenu && openSaveMenu !== menu) { + closeSaveMenu(openSaveMenu); + } + if (menu.classList.contains("querychat-save-menu--visible")) { + closeSaveMenu(menu); + } else { + menu.classList.add("querychat-save-menu--visible"); + openSaveMenu = menu; + } + } + function handleSaveExport(event, button, format, adapter) { + event.stopPropagation(); + const widgetId = button.dataset.widgetId; + if (!widgetId) { + return; + } + const filename = button.dataset.title || "chart"; + const menu = button.closest(".querychat-save-menu"); + if (menu) { + closeSaveMenu(menu); + } + adapter.exportPlot(widgetId, format, filename); + } + function handleCopy(event, button) { + event.stopPropagation(); + const query = button.dataset.query; + if (!query) { + return; + } + navigator.clipboard.writeText(query).then(() => { + const original = button.textContent; + button.textContent = "Copied!"; + setTimeout(() => { + button.textContent = original; + }, 2e3); + }).catch((error) => { + console.error("Failed to copy:", error); + }); + } + function installVizFooter(adapter) { + window.addEventListener("click", (event) => { + const target = event.target; + if (!(target instanceof Element)) { + closeOpenSaveMenu(); + return; + } + const actionElement = target.closest("[data-querychat-action]"); + const action = actionElement?.dataset.querychatAction; + if (!action || !actionElement) { + closeOpenSaveMenu(); + return; + } + switch (action) { + case "show-query": + handleShowQuery(event, actionElement); + return; + case "save-toggle": + handleSaveToggle(event, actionElement); + return; + case "save-png": + handleSaveExport(event, actionElement, "png", adapter); + return; + case "save-svg": + handleSaveExport(event, actionElement, "svg", adapter); + return; + case "copy": + handleCopy(event, actionElement); + return; + } + }); + } + function createVegaActionAdapter() { + return { + exportPlot(widgetId, format, filename) { + const container = findWidgetContainer(widgetId); + if (!container) { + return; + } + const link = findVegaAction(container, format); + if (!link) { + return; + } + triggerVegaAction(link, `${filename}.${format}`); + } + }; + } + + // src/viz.ts + installVizFooter(createVegaActionAdapter()); +})(); diff --git a/pkg-r/inst/prompts/ggsql-syntax.md b/pkg-r/inst/prompts/ggsql-syntax.md new file mode 100644 index 000000000..868d7c334 --- /dev/null +++ b/pkg-r/inst/prompts/ggsql-syntax.md @@ -0,0 +1,553 @@ +## ggsql Syntax Reference + +### Quick Reference + +```sql +[WITH cte AS (...), ...] +[SELECT columns FROM table WHERE conditions] +VISUALISE [mappings] [FROM source] +DRAW geom_type + [MAPPING col AS aesthetic, ... FROM source] + [REMAPPING stat AS aesthetic, ...] + [SETTING param => value, ...] + [FILTER sql_condition] + [PARTITION BY col, ...] + [ORDER BY col [ASC|DESC], ...] +[SCALE [TYPE] aesthetic [FROM ...] [TO ...] [VIA ...] [SETTING ...] [RENAMING ...]] +[PROJECT [aesthetics] TO coord_system [SETTING ...]] +[FACET var | row_var BY col_var [SETTING free => 'x'|'y'|('x','y'), ncol => N, nrow => N]] +[PLACE geom_type SETTING param => value, ...] +[LABEL x => '...', y => '...', ...] +``` + +### VISUALISE Clause + +Entry point for visualization. Marks where SQL ends and visualization begins. Mappings in VISUALISE and MAPPING accept **column names only** — no SQL expressions, functions, or casts. All data transformations must happen in the SELECT clause. + +```sql +-- After SELECT (most common) +SELECT date, revenue, region FROM sales +VISUALISE date AS x, revenue AS y, region AS color +DRAW line + +-- Shorthand with FROM (auto-generates SELECT * FROM) +VISUALISE FROM sales +DRAW bar MAPPING region AS x, total AS y + +-- FROM can also come first +FROM sales +VISUALISE date AS x, revenue AS y +DRAW line +``` + +### Mapping Styles + +| Style | Syntax | Use When | +|-------|--------|----------| +| Explicit | `date AS x` | Column name differs from aesthetic | +| Implicit | `x` | Column name equals aesthetic name | +| Wildcard | `*` | Map all matching columns automatically | +| Literal | `'string' AS color` | Use a literal value (for legend labels in multi-layer plots) | +| Null | `null AS color` | Suppress an inherited global mapping for this layer | + +### DRAW Clause (Layers) + +Multiple DRAW clauses create layered visualizations. + +```sql +DRAW geom_type + [MAPPING col AS aesthetic, ... FROM source] + [REMAPPING stat AS aesthetic, ...] + [SETTING param => value, ...] + [FILTER sql_condition] + [PARTITION BY col, ...] + [ORDER BY col [ASC|DESC], ...] +``` + +**Geom types:** + +| Category | Types | +|----------|-------| +| Basic | `point`, `line`, `path`, `bar`, `area`, `tile`, `polygon`, `ribbon` | +| Statistical | `histogram`, `density`, `smooth`, `boxplot`, `violin` | +| Annotation | `text`, `label`, `segment`, `arrow`, `rule`, `rect`, `range` | + +- `path` is like `line` but preserves data order instead of sorting by x. +- `tile` draws rectangles for heatmaps or range indicators. Map `x`/`y` for center (defaults to width/height of 1), or use `xmin`/`xmax`/`ymin`/`ymax` for explicit bounds. +- `smooth` fits a trendline to data. Settings: `method` (`'nw'` default for kernel regression, `'ols'` for linear, `'tls'` for total least squares), `bandwidth`, `adjust`, `kernel`. +- `text` (or `label`) renders text labels. Map `label` for the text content. Settings: `format` (template string for label formatting), `offset` (pixel offset as `(x, y)`). Labels containing `\n` are automatically split into multiple lines. +- `arrow` draws arrows between two points. Requires `x`, `y`, `xend`, `yend` aesthetics. +- `rule` draws full-span reference lines. Map a value to `y` for a horizontal line or `x` for a vertical line. Optionally map `slope` to create diagonal reference lines: `y = a + slope * x` (when `y` is mapped) or `x = a + slope * y` (when `x` is mapped). +- `rect` draws rectangles. Pick 2 per axis from center (`x`/`y`), min (`xmin`/`ymin`), max (`xmax`/`ymax`), `width`, `height`. Or just map center (defaults to width/height of 1). +- `range` displays interval marks. Requires `x`, `ymin`, `ymax` for vertical intervals, or `y`, `xmin`, `xmax` for horizontal intervals. Use it for confidence intervals, lollipops, and candlestick-style ranges. Setting `width => null` hides the hinges. +- `segment` draws arbitrary connections between two points and requires `x`, `y`, `xend`, and `yend`. +- `line` and `path` support continuously varying `linewidth`, `stroke`, and `opacity` aesthetics within groups. + +**Aesthetics (MAPPING):** + +| Category | Aesthetics | +|----------|------------| +| Position | `x`, `y`, `xmin`, `xmax`, `ymin`, `ymax`, `xend`, `yend` | +| Color | `color`/`colour`, `fill`, `stroke`, `opacity` | +| Size/Shape | `size`, `shape`, `linewidth`, `linetype`, `width`, `height` | +| Text | `label`, `typeface`, `fontweight`, `italic`, `fontsize`, `hjust`, `vjust`, `rotation` | +| Aggregation | `weight` (for histogram/bar/density/violin) | +| Rule | `slope` (for diagonal `rule` lines) | + +**PARTITION BY** groups data without visual encoding (useful for separate lines per group without color): + +```sql +DRAW line PARTITION BY category +``` + +**ORDER BY** controls row ordering within a layer: + +```sql +DRAW line ORDER BY date ASC +``` + +### PLACE Clause (Annotations) + +`PLACE` creates annotation layers with literal values only — no data mappings. Use it for reference lines, text labels, and other fixed annotations. All aesthetics are set via `SETTING` and bypass scaling. + +```sql +PLACE geom_type SETTING param => value, ... +``` + +**Examples:** +```sql +-- Horizontal reference line +PLACE rule SETTING y => 100 + +-- Vertical reference line +PLACE rule SETTING x => '2024-06-01' + +-- Multiple reference lines (array values) +PLACE rule SETTING y => (50, 75, 100) + +-- Text annotation +PLACE text SETTING x => 10, y => 50, label => 'Threshold' + +-- Diagonal reference line (y = -1 + 0.4 * x) +PLACE rule SETTING slope => 0.4, y => -1 +``` + +`PLACE` supports any geom type but is most useful with `rule`, `text`, `segment`, and `tile`. Use `PLACE` for fixed annotation values known at query time; use `DRAW` with `MAPPING` when values come from data columns. Unlike `DRAW`, `PLACE` has no `MAPPING`, `FILTER`, `PARTITION BY`, or `ORDER BY` sub-clauses. Array values in PLACE SETTING are recycled into multiple rows only for supported aesthetics; geom parameters (like `offset` on `text`) are passed through as-is. + +### Statistical Layers and REMAPPING + +Some layers compute statistics. Use REMAPPING to access computed values: + +| Layer | Computed Stats | Default Remapping | +|-------|---------------|-------------------| +| `bar` (y unmapped) | `count`, `proportion` | `count AS y` | +| `histogram` | `count`, `density` | `count AS y` | +| `density` | `density`, `intensity` | `density AS y` | +| `violin` | `density`, `intensity` | `density AS offset` | +| `smooth` | `intensity` | `intensity AS y` | +| `boxplot` | `value`, `type` | `value AS y` | + +`boxplot` displays box-and-whisker plots. Settings: `outliers` (`true` default — show outlier points), `coef` (`1.5` default — whisker fence coefficient), `width` (`0.9` default — box width, 0–1). + +`smooth` fits a trendline to data. Settings: `method` (`'nw'` or `'nadaraya-watson'` default kernel regression, `'ols'` for OLS linear, `'tls'` for total least squares). NW-only settings: `bandwidth` (numeric), `adjust` (multiplier, default 1), `kernel` (`'gaussian'` default, `'epanechnikov'`, `'triangular'`, `'rectangular'`, `'uniform'`, `'biweight'`, `'quartic'`, `'cosine'`). + +`density` computes a KDE from a continuous `x`. Settings: `bandwidth` (numeric), `adjust` (multiplier, default 1), `kernel` (`'gaussian'` default, `'epanechnikov'`, `'triangular'`, `'rectangular'`, `'uniform'`, `'biweight'`, `'quartic'`, `'cosine'`). Use `REMAPPING intensity AS y` to show unnormalized density that reflects group size differences. Use `SETTING position => 'stack'` for stacked densities. + +`violin` displays mirrored KDE curves for groups. Requires both `x` (categorical) and `y` (continuous). Accepts the same bandwidth/adjust/kernel settings as density. Use `REMAPPING intensity AS offset` to reflect group size differences. Additional settings: `side` (`'both'` default, `'left'`/`'bottom'`, `'right'`/`'top'` — for half-violin/ridgeline plots), `width` (any value > 0; values > 1 enable ridgeline-style overlapping). + +**Examples:** + +```sql +-- Density histogram (instead of count) +VISUALISE FROM products +DRAW histogram MAPPING price AS x REMAPPING density AS y + +-- Bar showing proportion +VISUALISE FROM sales +DRAW bar MAPPING region AS x REMAPPING proportion AS y + +-- Overlay histogram and density on the same scale +VISUALISE FROM measurements +DRAW histogram MAPPING value AS x SETTING opacity => 0.5 +DRAW density MAPPING value AS x REMAPPING intensity AS y SETTING opacity => 0.5 + +-- Violin plot +SELECT department, salary FROM employees +VISUALISE department AS x, salary AS y +DRAW violin +``` + +### SCALE Clause + +Configures how data maps to visual properties. All sub-clauses are optional; type and transform are auto-detected from data when omitted. + +```sql +SCALE [TYPE] aesthetic [FROM range] [TO output] [VIA transform] [SETTING prop => value, ...] [RENAMING ...] +``` + +**Type identifiers** (optional — auto-detected if omitted): + +| Type | Description | +|------|-------------| +| `CONTINUOUS` | Numeric data on a continuous axis | +| `DISCRETE` | Categorical/nominal data | +| `BINNED` | Pre-bucketed data | +| `ORDINAL` | Ordered categories with interpolated output | +| `IDENTITY` | Data values are already visual values (e.g., literal hex colors) | + +**Important — integer columns used as categories:** When an integer column represents categories (e.g., a 0/1 `survived` column), ggsql will treat it as continuous by default. This causes errors when mapping to `fill`, `color`, `shape`, or using it in `FACET`. Two fixes: +- **Preferred:** Cast to string in the SELECT clause: `SELECT CAST(survived AS VARCHAR) AS survived ...`, then map the column by name in VISUALISE: `survived AS fill` +- **Alternative:** Declare the scale: `SCALE DISCRETE fill` or `SCALE fill VIA bool` + +**FROM** — input domain: +```sql +SCALE x FROM (0, 100) -- explicit min and max +SCALE x FROM (0, null) -- explicit min, auto max +SCALE DISCRETE x FROM ('A', 'B', 'C') -- explicit category order +``` + +**TO** — output range or palette: +```sql +SCALE color TO sequential -- default continuous palette (derived from navia) +SCALE color TO viridis -- other continuous: viridis, plasma, inferno, magma, cividis, navia, batlow +SCALE color TO vik -- diverging: vik, rdbu, rdylbu, spectral, brbg, berlin, roma +SCALE DISCRETE color TO ggsql10 -- discrete (default: ggsql10): tableau10, category10, set1, set2, set3, dark2, paired, kelly +SCALE color TO ('red', 'blue') -- explicit color array +SCALE size TO (1, 10) -- numeric output range +``` + +**VIA** — transformation: +```sql +SCALE x VIA date -- date axis (auto-detected from Date columns) +SCALE x VIA datetime -- datetime axis +SCALE y VIA log10 -- base-10 logarithm +SCALE y VIA sqrt -- square root +``` + +| Category | Transforms | +|----------|------------| +| Logarithmic | `log10`, `log2`, `log` (natural) | +| Power | `sqrt`, `square` | +| Exponential | `exp`, `exp2`, `exp10` | +| Other | `asinh`, `pseudo_log` | +| Temporal | `date`, `datetime`, `time` | +| Type coercion | `integer`, `string`, `bool` | + +**SETTING** — additional properties: +```sql +SCALE x SETTING breaks => 5 -- number of tick marks +SCALE x SETTING breaks => '2 months' -- interval-based breaks +SCALE x SETTING expand => 0.05 -- expand scale range by 5% +SCALE x SETTING reverse => true -- reverse direction +SCALE y FROM (0, 100) SETTING oob => 'squish' -- squish out-of-bounds values to range boundary +``` + +`oob` (out-of-bounds) controls data outside the scale range: `'keep'` (default for x/y), `'censor'` (remove, default for other aesthetics), `'squish'` (clamp to boundary). + +**RENAMING** — custom axis/legend labels: +```sql +SCALE DISCRETE x RENAMING 'A' => 'Alpha', 'B' => 'Beta' +SCALE CONTINUOUS x RENAMING * => '{} units' -- template for all labels +SCALE x VIA date RENAMING * => '{:time %b %Y}' -- date label formatting +``` + +### Date/Time Axes + +Temporal transforms are auto-detected from column data types, including after `DATE_TRUNC`. + +**Break intervals:** +```sql +SCALE x SETTING breaks => 'month' -- one break per month +SCALE x SETTING breaks => '2 weeks' -- every 2 weeks +SCALE x SETTING breaks => '3 months' -- quarterly +SCALE x SETTING breaks => 'year' -- yearly +``` + +Valid units: `day`, `week`, `month`, `year` (for date); also `hour`, `minute`, `second` (for datetime/time). + +**Date label formatting** (strftime syntax): +```sql +SCALE x VIA date RENAMING * => '{:time %b %Y}' -- "Jan 2024" +SCALE x VIA date RENAMING * => '{:time %B %d, %Y}' -- "January 15, 2024" +SCALE x VIA date RENAMING * => '{:time %b %d}' -- "Jan 15" +``` + +### PROJECT Clause + +Sets coordinate system. Use `PROJECT ... TO` to specify coordinates. + +**Coordinate systems:** `cartesian` (default), `polar`. + +**Polar aesthetics:** In polar coordinates, positional aesthetics use `angle` and `radius` (instead of `x` and `y`). Variants `anglemin`, `anglemax`, `angleend`, `radiusmin`, `radiusmax`, `radiusend` are also available. Typically you map to `x`/`y` and let `PROJECT TO polar` handle the conversion, but you can use `angle`/`radius` explicitly when needed. + +```sql +PROJECT TO cartesian -- explicit default (usually omitted) +PROJECT y, x TO cartesian -- flip axes (maps y to horizontal, x to vertical) +PROJECT TO polar -- pie/radial charts +PROJECT TO polar SETTING start => 90 -- start at 3 o'clock +PROJECT TO polar SETTING inner => 0.5 -- donut chart (50% hole) +PROJECT TO polar SETTING start => -90, end => 90 -- half-circle gauge +``` + +**Cartesian settings:** +- `clip` — clip out-of-bounds data (default `true`) +- `ratio` — enforce aspect ratio between axes + +**Polar settings:** +- `start` — starting angle in degrees (0 = 12 o'clock, 90 = 3 o'clock) +- `end` — ending angle in degrees (default: start + 360; use for partial arcs/gauges) +- `inner` — inner radius as proportion 0–1 (0 = full pie, 0.5 = donut with 50% hole) +- `clip` — clip out-of-bounds data (default `true`) + +**Axis flipping:** To create horizontal bar charts or flip axes, use `PROJECT y, x TO cartesian`. This maps anything on `y` to the horizontal axis and `x` to the vertical axis. + +### FACET Clause + +Creates small multiples (subplots by category). + +```sql +FACET category -- Single variable, wrapped layout +FACET row_var BY col_var -- Grid layout (rows x columns) +FACET category SETTING free => 'y' -- Independent y-axes +FACET category SETTING free => ('x', 'y') -- Independent both axes +FACET category SETTING ncol => 4 -- Control number of columns +FACET category SETTING nrow => 2 -- Control number of rows (mutually exclusive with ncol) +``` + +Custom strip labels via SCALE: +```sql +FACET region +SCALE panel RENAMING 'N' => 'North', 'S' => 'South' +``` + +Filter to specific panels via SCALE FROM: +```sql +FACET island +SCALE panel FROM ('Biscoe', 'Dream') +``` + +### LABEL Clause + +Use LABEL for axis labels, subtitles, and captions. Do NOT use `LABEL title => ...` — the tool's `title` parameter handles chart titles. Set a label to `null` to suppress it. + +Available labels: any aesthetic name (`x`, `y`, `fill`, `color`, etc.), `subtitle`, `caption`. + +```sql +LABEL x => 'X Axis Label', y => 'Y Axis Label' +LABEL x => null -- suppress x-axis label +LABEL subtitle => 'Q4 2024 data', caption => 'Source: internal database' +``` + +## Complete Examples + +**Line chart with multiple series:** +```sql +SELECT date, revenue, region FROM sales WHERE year = 2024 +VISUALISE date AS x, revenue AS y, region AS color +DRAW line +SCALE x VIA date +LABEL x => 'Date', y => 'Revenue ($)' +``` + +**Bar chart (auto-count):** +```sql +VISUALISE FROM products +DRAW bar MAPPING category AS x +``` + +**Horizontal bar chart:** +```sql +SELECT region, COUNT(*) as n FROM sales GROUP BY region +VISUALISE region AS y, n AS x +DRAW bar +PROJECT y, x TO cartesian +``` + +**Scatter plot with trend line:** +```sql +SELECT mpg, hp, cylinders FROM cars +VISUALISE mpg AS x, hp AS y +DRAW point MAPPING cylinders AS color +DRAW smooth +``` + +**Histogram with density overlay:** +```sql +VISUALISE FROM measurements +DRAW histogram MAPPING value AS x SETTING bins => 20, opacity => 0.5 +DRAW density MAPPING value AS x REMAPPING intensity AS y SETTING opacity => 0.5 +``` + +**Density plot with groups:** +```sql +VISUALISE FROM measurements +DRAW density MAPPING value AS x, category AS color SETTING opacity => 0.7 +``` + +**Heatmap with tile:** +```sql +SELECT day, month, temperature FROM weather +VISUALISE day AS x, month AS y, temperature AS color +DRAW tile +``` + +**Threshold reference lines (using PLACE):** +```sql +SELECT date, temperature FROM sensor_data +VISUALISE date AS x, temperature AS y +DRAW line +PLACE rule SETTING y => 100, stroke => 'red', linetype => 'dashed' +LABEL y => 'Temperature (F)' +``` + +**Faceted chart:** +```sql +SELECT month, sales, region FROM data +VISUALISE month AS x, sales AS y +DRAW line +DRAW point +FACET region +SCALE x VIA date +``` + +**CTE with aggregation and date formatting:** +```sql +WITH monthly AS ( + SELECT DATE_TRUNC('month', order_date) as month, SUM(amount) as total + FROM orders GROUP BY 1 +) +VISUALISE month AS x, total AS y FROM monthly +DRAW line +DRAW point +SCALE x VIA date SETTING breaks => 'month' RENAMING * => '{:time %b %Y}' +LABEL y => 'Revenue ($)' +``` + +**Ribbon / confidence band:** +```sql +WITH daily AS ( + SELECT DATE_TRUNC('day', timestamp) as day, + AVG(temperature) as avg_temp, + MIN(temperature) as min_temp, + MAX(temperature) as max_temp + FROM sensor_data + GROUP BY DATE_TRUNC('day', timestamp) +) +VISUALISE day AS x FROM daily +DRAW ribbon MAPPING min_temp AS ymin, max_temp AS ymax SETTING opacity => 0.3 +DRAW line MAPPING avg_temp AS y +SCALE x VIA date +LABEL y => 'Temperature' +``` + +**Text labels on bars:** +```sql +SELECT region, COUNT(*) AS n FROM sales GROUP BY region +VISUALISE region AS x, n AS y +DRAW bar +DRAW text MAPPING n AS label SETTING offset => (0, -11), fill => 'white' +``` + +**Lollipop chart:** +```sql +SELECT ROUND(bill_dep) AS bill_dep, COUNT(*) AS n FROM penguins GROUP BY 1 +VISUALISE bill_dep AS x, n AS y +DRAW range MAPPING 0 AS ymin, n AS ymax SETTING width => null +DRAW point +``` + +**Ridgeline / joy plot:** +```sql +VISUALISE temp AS x, month AS y FROM weather +DRAW violin SETTING width => 4, side => 'top' +SCALE ORDINAL y +``` + +**Donut chart:** +```sql +VISUALISE FROM products +DRAW bar MAPPING category AS fill +PROJECT TO polar SETTING inner => 0.5 +``` + +## Important Notes + +1. **Numeric columns as categories**: Integer columns representing categories (e.g., 0/1 `survived`) are treated as continuous by default, causing errors with `fill`, `color`, `shape`, and `FACET`. Fix by casting in SQL or declaring the scale: + ```sql + -- WRONG: integer fill without discrete scale — causes validation error + SELECT sex, survived FROM titanic + VISUALISE sex AS x, survived AS fill + DRAW bar + + -- CORRECT: cast to string in SQL (preferred) + SELECT sex, CAST(survived AS VARCHAR) AS survived FROM titanic + VISUALISE sex AS x, survived AS fill + DRAW bar + + -- ALSO CORRECT: declare the scale as discrete + SELECT sex, survived FROM titanic + VISUALISE sex AS x, survived AS fill + DRAW bar + SCALE DISCRETE fill + ``` +2. **Do not mix `VISUALISE FROM` with a preceding `SELECT`**: `VISUALISE FROM table` is shorthand that auto-generates `SELECT * FROM table`. If you already have a `SELECT`, use `SELECT ... VISUALISE` instead: + ```sql + -- WRONG: VISUALISE FROM after SELECT + SELECT * FROM titanic + VISUALISE FROM titanic + DRAW bar MAPPING class AS x + + -- CORRECT: use VISUALISE (without FROM) after SELECT + SELECT * FROM titanic + VISUALISE class AS x + DRAW bar + + -- ALSO CORRECT: use VISUALISE FROM without any SELECT + VISUALISE FROM titanic + DRAW bar MAPPING class AS x + ``` +3. **In querychat, all layers must come from the final SQL result**: Do not use layer-specific `FROM source` inside `DRAW ... MAPPING ...` clauses. If you need raw data and a summary in one chart, put both into one final relation and distinguish layers with a column such as `layer_type`: + ```sql + WITH raw AS ( + SELECT + date, + amount, + region, + 'raw' AS layer_type + FROM sales + ), + summary AS ( + SELECT + date, + AVG(amount) AS amount, + region, + 'summary' AS layer_type + FROM sales + GROUP BY date, region + ), + combined AS ( + SELECT * FROM raw + UNION ALL + SELECT * FROM summary + ) + SELECT * FROM combined + VISUALISE date AS x, amount AS y + DRAW point MAPPING region AS color FILTER layer_type = 'raw' + DRAW line MAPPING region AS color FILTER layer_type = 'summary' + ``` +4. **String values use single quotes**: In SETTING, LABEL, and RENAMING clauses, always use single quotes for string values. Double quotes cause parse errors. +5. **Statistical layers**: When using `histogram`, `bar` (without y), `density`, `smooth`, `violin`, or `boxplot`, the layer computes statistics. Use REMAPPING to access `density`, `intensity`, `proportion`, etc. +6. **No trailing commas**: SETTING, LABEL, MAPPING, and RENAMING clauses must not end with a trailing comma. A comma after the last item causes a parse error. + ```sql + -- WRONG: trailing comma after the last label + LABEL x => 'Gender', y => 'Count', + + -- CORRECT + LABEL x => 'Gender', y => 'Count' + ``` +7. **Bar position adjustments**: Bars stack automatically when `fill` is mapped. Use `SETTING position => 'dodge'` for side-by-side bars, or `position => 'stack', total => 1` for proportional (100%) stacking: + ```sql + DRAW bar MAPPING category AS x, subcategory AS fill -- stacked (default) + DRAW bar MAPPING category AS x, subcategory AS fill SETTING position => 'dodge' -- side-by-side + DRAW bar MAPPING category AS x, subcategory AS fill SETTING position => 'stack', total => 1 -- proportional + ``` diff --git a/pkg-r/inst/prompts/prompt.md b/pkg-r/inst/prompts/prompt.md index 8c6ff97bc..b426ba661 100644 --- a/pkg-r/inst/prompts/prompt.md +++ b/pkg-r/inst/prompts/prompt.md @@ -1,4 +1,4 @@ -You are a data dashboard chatbot that operates in a sidebar interface. Your role is to help users interact with their data through filtering, sorting, and answering questions. +You are a data dashboard chatbot that operates in a sidebar interface. Your role is to help users interact with their data through filtering, sorting, and answering questions.{{#has_tool_visualize}} You can also help them explore data visually.{{/has_tool_visualize}} You have access to a {{db_type}} SQL database with the following schema: @@ -118,11 +118,95 @@ Response: "The average revenue is $X." This simple response is sufficient, as the user can see the SQL query used. {{/has_tool_query}} +{{#has_tool_visualize}} +### Visualizing Data + +You can create visualizations using the `querychat_visualize` tool, which uses ggsql — a SQL extension for declarative data visualization. Write a ggsql query (SQL with a VISUALISE clause), and the tool executes the SQL, renders the VISUALISE clause as an interactive chart, and displays it inline in the chat. + +#### Visualization best practices + +The database schema in this prompt includes column names, types, and summary statistics. {{#has_tool_query}}If that context isn't sufficient for a confident visualization — e.g., you're unsure about value distributions, need to check for NULLs, or want to gauge row counts before choosing a chart type — use the `querychat_query` tool to inspect the data before visualizing. Always pass `collapsed=true` for these preparatory queries so the chart remains the focal point of the response.{{/has_tool_query}} + +Follow the principles below to produce clear, interpretable charts. + +#### Axis labels must be readable + +When the x-axis contains categorical labels (names, categories, long strings), prefer flipping axes with `PROJECT y, x TO cartesian` so labels read naturally left-to-right. Short numeric or date labels on the x-axis are fine horizontal — this applies specifically to text categories. + +#### Always include axis labels with units + +Charts should be interpretable without reading the surrounding prose. Always include axis labels that describe what is shown, including units when applicable (e.g., `LABEL y => 'Revenue ($M)'`, not just `LABEL y => 'Revenue'`). + +#### Maximize data-ink ratio + +Every visual element should serve a purpose: + +- Don't map columns to aesthetics (color, size, shape) unless the distinction is meaningful to the user's question. A single-series bar chart doesn't need color. +- When using color for categories, keep to 7 or fewer distinct values. Beyond that, consider filtering to the most important categories or using facets instead. +- Avoid dual-encoding the same variable (e.g., mapping the same column to both x-position and color) unless it genuinely aids interpretation. + +#### Avoid overplotting + +When a dataset has many rows, plotting one mark per row creates clutter that obscures patterns. Before generating a query, consider the row count and data characteristics visible in the schema. + +**For large datasets (hundreds+ rows):** + +- **Aggregate first**: Use `GROUP BY` with `COUNT`, `AVG`, `SUM`, or other aggregates to reduce to meaningful summaries before visualizing. +- **Choose chart types that summarize naturally**: histograms for distributions, boxplots for group comparisons, line charts for trends over time. + +**For two numeric variables with many rows:** + +Bin in SQL and use `DRAW tile` to create a heatmap: + +```sql +WITH binned AS ( + SELECT ROUND(x_col / 5) * 5 AS x_bin, + ROUND(y_col / 5) * 5 AS y_bin, + COUNT(*) AS n + FROM large_table + GROUP BY x_bin, y_bin +) +SELECT * FROM binned +VISUALISE x_bin AS x, y_bin AS y, n AS fill +DRAW tile +SCALE fill TO viridis +``` + +**If individual points matter** (e.g., outlier detection): use `SETTING opacity` to reveal density through overlap. + +#### Choose chart types based on the data relationship + +Match the chart type to what the user is trying to understand: + +- **Comparison across categories**: bar chart (`DRAW bar`, with `PROJECT y, x TO cartesian` for long labels). Order bars by value, not alphabetically. +- **Trend over time**: line chart (`DRAW line`). Use `SCALE x VIA date` for date columns. +- **Distribution of a single variable**: histogram (`DRAW histogram`) or density (`DRAW density`). +- **Relationship between two numeric variables**: scatter plot (`DRAW point`), but prefer aggregation or heatmap if the dataset is large. +- **Part-of-whole**: stacked bar chart (map subcategory to `fill`). Avoid pie charts — position along a common scale is easier to decode than angle. + +#### ggsql syntax reference + + +{{> ggsql-syntax}} + +{{#has_tool_query}} + +**Avoid redundant expanded results.** If you run a preparatory query before visualizing, or if both a table and chart would show the same data, always pass `collapsed=true` on the query so the user sees the chart prominently, not a duplicate table above it. The user can still expand the table if they want the exact values. +{{/has_tool_query}} +{{/has_tool_visualize}} +{{^has_tool_visualize}} +### Visualization Requests + +You cannot create charts or visualizations. If users ask for a plot, chart, or visual representation of the data, explain that visualization is not currently enabled.{{#has_tool_query}} Offer to answer their question with a tabular query instead.{{/has_tool_query}} Suggest that the developer can enable visualization by installing the `ggsql` package and adding `"visualize"` to the `tools` parameter. + +{{/has_tool_visualize}} {{^has_tool_query}} +{{^has_tool_visualize}} ### Questions About Data You cannot query or analyze the data. If users ask questions about data values, statistics, or calculations (e.g., "What is the average ____?" or "How many ____ are there?"), explain that you're not able to run queries on this data. Do not attempt to answer based on your own knowledge or assumptions about the data, even if the dataset seems familiar. +{{/has_tool_visualize}} {{/has_tool_query}} ### Providing Suggestions for Next Steps @@ -146,9 +230,16 @@ You might want to explore the advanced features **Nested lists:** ```md +{{#has_tool_query}} * Analyze the data * What's the average …? * How many …? +{{/has_tool_query}} +{{#has_tool_visualize}} +* Visualize the data + * Show a bar chart of … + * Plot the trend of … over time +{{/has_tool_visualize}} * Filter and sort * Show records from the year … * Sort the ____ by ____ … @@ -185,6 +276,7 @@ You might want to explore the advanced features - **Ask for clarification** if any request is unclear or ambiguous - **Be concise** due to the constrained interface - **Only answer data questions using your tools** - never use prior knowledge or assumptions about the data, even if the dataset seems familiar +- **Be skeptical of your own interpretations** - when describing chart results or data patterns, encourage the user to verify findings rather than presenting analytical conclusions as fact - **Use Markdown tables** for any tabular or structured data in your responses {{#extra_instructions}} diff --git a/pkg-r/inst/prompts/tool-query.md b/pkg-r/inst/prompts/tool-query.md index 20e1dbb53..246cc90ee 100644 --- a/pkg-r/inst/prompts/tool-query.md +++ b/pkg-r/inst/prompts/tool-query.md @@ -2,8 +2,6 @@ Execute a SQL query and return the results This tool executes a {{db_type}} SQL SELECT query against the database and returns the raw result data for analysis. -**Returns:** The tabular data results from executing the SQL query. The query results will be visible to the user in the interface, so you must interpret and explain the data in natural language after receiving it. - **When to use:** Call this tool whenever the user asks a question that requires data analysis, aggregation, or calculations. Use this for questions like: - "What is the average...?" - "How many records...?" @@ -22,3 +20,17 @@ Always use SQL for counting, averaging, summing, and other calculations—NEVER - Subqueries and CTEs are acceptable and encouraged for complex calculations - After receiving results, provide an explanation of the answer and an overview of how you arrived at it, if not already explained in SQL comments - The user can see your SQL query, they will follow up with detailed explanations if needed + +Parameters +---------- +query : + A valid {{db_type}} SQL SELECT statement. Must follow the database schema provided in the system prompt. Use clear column aliases (e.g., 'AVG(price) AS avg_price') and include SQL comments for complex logic. Subqueries and CTEs are encouraged for readability. +collapsed : + Optional (default: false). Set to true for exploratory or preparatory queries (e.g., inspecting data before visualization, checking row counts, previewing column values) whose results aren't the primary answer. When true, the result card starts collapsed so it doesn't clutter the conversation. +_intent : + A brief, user-friendly description of what this query calculates or retrieves. + +Returns +------- +: + The tabular data results from executing the SQL query. The query results will be visible to the user in the interface, so you must interpret and explain the data in natural language after receiving it. diff --git a/pkg-r/inst/prompts/tool-visualize.md b/pkg-r/inst/prompts/tool-visualize.md new file mode 100644 index 000000000..aa2bafcb8 --- /dev/null +++ b/pkg-r/inst/prompts/tool-visualize.md @@ -0,0 +1,23 @@ +Create a data visualization + +Render a ggsql query (SQL with a VISUALISE clause) as an interactive chart displayed inline in the chat. + +**When to use:** Call this tool when the user's question involves comparisons, distributions, or trends — even for small result sets, a chart is often clearer than a table.{{#has_tool_query}} For single-value answers (averages, counts, totals, specific lookups) or when the user needs exact values, use `querychat_query` instead.{{/has_tool_query}} + +**Key constraints:** + +- All data transformations must happen in the `SELECT` clause. `VISUALISE` and `MAPPING` accept column names only, not SQL expressions or functions. +- Do NOT include `LABEL title => ...` in the query — use the `title` parameter instead. +- If a visualization fails, read the error message carefully and retry with a corrected query. Common fixes: correcting column names, adding `SCALE DISCRETE` for integer categories, moving SQL expressions out of `VISUALISE` into the `SELECT` clause, and using `DRAW range` for interval-style marks instead of deprecated `errorbar`.{{#has_tool_query}} If the error persists, fall back to `querychat_query` for a tabular answer.{{/has_tool_query}} + +Parameters +---------- +ggsql : + A full ggsql query. Must include a VISUALISE clause and at least one DRAW clause. The SELECT portion uses {{db_type}} SQL; VISUALISE and MAPPING accept column names only, not expressions. Do NOT include `LABEL title => ...` in the query — use the `title` parameter instead. +title : + A brief, user-friendly title for this visualization. This is displayed as the card header above the chart. + +Returns +------- +: + If successful, a static image of the rendered plot. If not, an error message. diff --git a/pkg-r/man/QueryChat.Rd b/pkg-r/man/QueryChat.Rd index da67c32e1..30abb9809 100644 --- a/pkg-r/man/QueryChat.Rd +++ b/pkg-r/man/QueryChat.Rd @@ -232,7 +232,10 @@ data source. update_dashboard = function(query, title) { }, reset_dashboard = function() { - } + }, + visualize = function(data) { + }, + session = NULL )}\if{html}{\out{}} } @@ -249,6 +252,14 @@ when \code{tools = NA}, the values provided at initialization are used.} \item{\code{reset_dashboard}}{Optional function to call when the \code{reset_dashboard} tool is called.} + +\item{\code{visualize}}{Optional function to call with a list containing +\code{ggsql}, \code{title}, and \code{widget_id} when a visualization succeeds.} + +\item{\code{session}}{A Shiny session object. Required when \code{"visualize"} is +in \code{tools} and you want interactive chart rendering. When \code{NULL} +(the default), visualizations still execute but are not rendered +as Shiny outputs.} } \if{html}{\out{}} } diff --git a/pkg-r/man/execute_ggsql.Rd b/pkg-r/man/execute_ggsql.Rd new file mode 100644 index 000000000..3713aab02 --- /dev/null +++ b/pkg-r/man/execute_ggsql.Rd @@ -0,0 +1,22 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/querychat_viz.R +\name{execute_ggsql} +\alias{execute_ggsql} +\title{Execute a pre-validated ggsql query against a DataSource} +\usage{ +execute_ggsql(data_source, validated) +} +\arguments{ +\item{data_source}{A querychat DataSource R6 object.} + +\item{validated}{A pre-validated ggsql query (from \code{ggsql::ggsql_validate()}). +Must be a list with \verb{$sql} and \verb{$visual} fields.} +} +\value{ +A \code{ggsql::Spec} R6 object (the writer-independent plot specification). +} +\description{ +Executes the SQL portion through a DataSource (preserving database pushdown), +then feeds the result into a ggsql DuckDB reader to produce a Spec. +} +\keyword{internal} diff --git a/pkg-r/man/extract_visualise_table.Rd b/pkg-r/man/extract_visualise_table.Rd new file mode 100644 index 000000000..dbc1039c7 --- /dev/null +++ b/pkg-r/man/extract_visualise_table.Rd @@ -0,0 +1,19 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/querychat_viz.R +\name{extract_visualise_table} +\alias{extract_visualise_table} +\title{Extract the table name from a VISUALISE clause's FROM, if present} +\usage{ +extract_visualise_table(visual) +} +\arguments{ +\item{visual}{A ggsql VISUALISE string.} +} +\value{ +The table name string (possibly quoted), or \code{NULL} if not present. +} +\description{ +Looks only in the portion of the visual string before the first DRAW keyword, +so FROM clauses inside DRAW (e.g., MAPPING x FROM other) are ignored. +} +\keyword{internal} diff --git a/pkg-r/man/has_layer_level_source.Rd b/pkg-r/man/has_layer_level_source.Rd new file mode 100644 index 000000000..bacaa5c33 --- /dev/null +++ b/pkg-r/man/has_layer_level_source.Rd @@ -0,0 +1,20 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/querychat_viz.R +\name{has_layer_level_source} +\alias{has_layer_level_source} +\title{Detect whether a VISUALISE string has a layer-level FROM source} +\usage{ +has_layer_level_source(visual) +} +\arguments{ +\item{visual}{A ggsql VISUALISE string.} +} +\value{ +\code{TRUE} if any DRAW clause contains a MAPPING ... FROM source. +} +\description{ +Returns \code{TRUE} when a DRAW clause defines its own \verb{FROM } via a +MAPPING sub-clause. Querychat replays VISUALISE against a single local +relation, so layer-specific sources cannot be preserved reliably. +} +\keyword{internal} diff --git a/pkg-r/tests/testthat/test-QueryChat.R b/pkg-r/tests/testthat/test-QueryChat.R index 71d1e6aa3..57ffc70c7 100644 --- a/pkg-r/tests/testthat/test-QueryChat.R +++ b/pkg-r/tests/testthat/test-QueryChat.R @@ -371,6 +371,69 @@ describe("QueryChat$client()", { expect_false("querychat_reset_dashboard" %in% tool_names) }) + it("registers visualize tool when tools include 'visualize'", { + skip_if_not_installed("ggsql") + session <- structure( + list( + output = list(), + ns = identity + ), + class = "MockShinySession" + ) + + qc <- QueryChat$new( + new_test_df(), + "test_df", + tools = c("query", "visualize") + ) + withr::defer(qc$cleanup()) + + client <- qc$client(tools = c("query", "visualize"), session = session) + + tool_names <- sapply(client$get_tools(), function(t) t@name) + expect_contains(tool_names, "querychat_query") + expect_contains(tool_names, "querychat_visualize") + expect_false("querychat_update_dashboard" %in% tool_names) + expect_false("querychat_reset_dashboard" %in% tool_names) + }) + + it("registers visualize tool without a session", { + skip_if_not_installed("ggsql") + + qc <- QueryChat$new( + new_test_df(), + "test_df" + ) + withr::defer(qc$cleanup()) + + client <- qc$client(tools = "visualize") + + tool_names <- sapply(client$get_tools(), function(t) t@name) + expect_equal(unname(tool_names), "querychat_visualize") + }) + + it("registers only visualize tool when tools = 'visualize'", { + skip_if_not_installed("ggsql") + session <- structure( + list( + output = list(), + ns = identity + ), + class = "MockShinySession" + ) + + qc <- QueryChat$new( + new_test_df(), + "test_df" + ) + withr::defer(qc$cleanup()) + + client <- qc$client(tools = "visualize", session = session) + + tool_names <- sapply(client$get_tools(), function(t) t@name) + expect_equal(unname(tool_names), "querychat_visualize") + }) + it("returns client with no tools when tools = NULL", { qc <- QueryChat$new( new_test_df(), diff --git a/pkg-r/tests/testthat/test-QueryChatSystemPrompt.R b/pkg-r/tests/testthat/test-QueryChatSystemPrompt.R index 4d773f184..5bf3e88e5 100644 --- a/pkg-r/tests/testthat/test-QueryChatSystemPrompt.R +++ b/pkg-r/tests/testthat/test-QueryChatSystemPrompt.R @@ -456,6 +456,83 @@ describe("QueryChatSystemPrompt with full prompt.md template", { }) }) +describe("viz prompt conditionals", { + skip_if_no_dataframe_engine() + + default_prompt <- function() { + system.file("prompts", "prompt.md", package = "querychat") + } + + it("includes viz section when visualize tool is active", { + ds <- local_data_frame_source(new_test_df()) + sp <- QueryChatSystemPrompt$new( + prompt_template = default_prompt(), + data_source = ds + ) + rendered <- sp$render(tools = c("query", "visualize")) + expect_match(rendered, "querychat_visualize") + expect_match(rendered, "ggsql") + expect_match(rendered, "VISUALISE") + }) + + it("excludes viz section without visualize tool", { + ds <- local_data_frame_source(new_test_df()) + sp <- QueryChatSystemPrompt$new( + prompt_template = default_prompt(), + data_source = ds + ) + rendered <- sp$render(tools = c("query")) + expect_no_match(rendered, "querychat_visualize") + }) + + it("shows fallback message without visualize tool", { + ds <- local_data_frame_source(new_test_df()) + sp <- QueryChatSystemPrompt$new( + prompt_template = default_prompt(), + data_source = ds + ) + rendered <- sp$render(tools = c("query")) + expect_match(rendered, "visualization is not currently enabled") + }) + + it("includes ggsql syntax reference as partial", { + ds <- local_data_frame_source(new_test_df()) + sp <- QueryChatSystemPrompt$new( + prompt_template = default_prompt(), + data_source = ds + ) + rendered <- sp$render(tools = c("visualize")) + expect_match(rendered, "ggsql-syntax-reference") + expect_match(rendered, "FROM sales") + expect_match(rendered, "DRAW range") + expect_match(rendered, "xend") + expect_no_match(rendered, "errorbar", ignore.case = TRUE) + expect_no_match(rendered, "DRAW segment MAPPING 0 AS yend", fixed = TRUE) + expect_no_match(rendered, "Column casing in VISUALISE", fixed = TRUE) + expect_no_match(rendered, "ROOM_TYPE", fixed = TRUE) + }) + + it("includes collapsed guidance when both query and visualize active", { + ds <- local_data_frame_source(new_test_df()) + sp <- QueryChatSystemPrompt$new( + prompt_template = default_prompt(), + data_source = ds + ) + rendered <- sp$render(tools = c("query", "visualize")) + expect_match(rendered, "Avoid redundant expanded results") + }) + + it("excludes collapsed guidance with visualize only", { + ds <- local_data_frame_source(new_test_df()) + sp <- QueryChatSystemPrompt$new( + prompt_template = default_prompt(), + data_source = ds + ) + rendered <- sp$render(tools = c("visualize")) + expect_no_match(rendered, "Avoid redundant expanded results") + }) +}) + describe("Schema inference skip", { skip_if_no_dataframe_engine() diff --git a/pkg-r/tests/testthat/test-collapsed-param.R b/pkg-r/tests/testthat/test-collapsed-param.R new file mode 100644 index 000000000..8f7d29187 --- /dev/null +++ b/pkg-r/tests/testthat/test-collapsed-param.R @@ -0,0 +1,56 @@ +describe("query tool collapsed parameter", { + skip_if_no_dataframe_engine() + + it("collapsed=TRUE sets open=FALSE in display", { + ds <- local_data_frame_source(new_test_df()) + tool <- tool_query(ds) + result <- tool( + query = "SELECT * FROM test_table", + `_intent` = "", + collapsed = TRUE + ) + expect_false(result@extra$display$open) + }) + + it("collapsed=FALSE sets open=TRUE in display", { + ds <- local_data_frame_source(new_test_df()) + tool <- tool_query(ds) + result <- tool( + query = "SELECT * FROM test_table", + `_intent` = "", + collapsed = FALSE + ) + expect_true(result@extra$display$open) + }) + + it("collapsed defaults to FALSE (open=TRUE for query)", { + ds <- local_data_frame_source(new_test_df()) + tool <- tool_query(ds) + result <- tool(query = "SELECT * FROM test_table", `_intent` = "") + expect_true(result@extra$display$open) + }) + + it("collapsed=TRUE overrides QUERYCHAT_TOOL_DETAILS=expanded", { + withr::local_options(querychat.tool_details = "expanded") + ds <- local_data_frame_source(new_test_df()) + tool <- tool_query(ds) + result <- tool( + query = "SELECT * FROM test_table", + `_intent` = "", + collapsed = TRUE + ) + expect_false(result@extra$display$open) + }) + + it("collapsed=FALSE overrides QUERYCHAT_TOOL_DETAILS=collapsed", { + withr::local_options(querychat.tool_details = "collapsed") + ds <- local_data_frame_source(new_test_df()) + tool <- tool_query(ds) + result <- tool( + query = "SELECT * FROM test_table", + `_intent` = "", + collapsed = FALSE + ) + expect_true(result@extra$display$open) + }) +}) diff --git a/pkg-r/tests/testthat/test-querychat-viz.R b/pkg-r/tests/testthat/test-querychat-viz.R new file mode 100644 index 000000000..865fe30d0 --- /dev/null +++ b/pkg-r/tests/testthat/test-querychat-viz.R @@ -0,0 +1,141 @@ +describe("extract_visualise_table()", { + it("extracts bare identifier", { + expect_equal( + extract_visualise_table( + "VISUALISE x AS x, y AS y FROM my_table DRAW point" + ), + "my_table" + ) + }) + + it("extracts quoted identifier", { + expect_equal( + extract_visualise_table('VISUALISE x AS x FROM "My Table" DRAW point'), + '"My Table"' + ) + }) + + it("returns NULL when no FROM in VISUALISE", { + expect_null(extract_visualise_table("VISUALISE x AS x, y AS y DRAW point")) + }) + + it("ignores FROM inside DRAW clause", { + visual <- "VISUALISE x AS x FROM data DRAW point MAPPING x FROM other" + expect_equal(extract_visualise_table(visual), "data") + }) +}) + +describe("has_layer_level_source()", { + it("detects DRAW-level FROM source", { + expect_true( + has_layer_level_source( + "VISUALISE x AS x DRAW point MAPPING x FROM my_table" + ) + ) + }) + + it("ignores VISUALISE-level FROM", { + expect_false( + has_layer_level_source( + "VISUALISE x AS x FROM my_table DRAW point" + ) + ) + }) + + it("ignores SCALE FROM", { + expect_false( + has_layer_level_source( + "VISUALISE x AS x DRAW bar SCALE fill FROM 'red'" + ) + ) + }) +}) + +describe("execute_ggsql()", { + skip_if_no_dataframe_engine() + skip_if_not_installed("ggsql") + + it("executes a basic ggsql query", { + ds <- local_data_frame_source(new_test_df()) + validated <- ggsql::ggsql_validate( + "SELECT * FROM test_table VISUALISE value AS x DRAW histogram" + ) + spec <- execute_ggsql(ds, validated) + expect_s3_class(spec, "Spec") + }) + + it("supports uppercase column references without renaming", { + df <- data.frame( + ROOM_TYPE = c("Entire home", "Private room"), + listings = c(10, 20) + ) + ds <- local_data_frame_source(df, table_name = "upper_table") + validated <- ggsql::ggsql_validate( + paste( + "SELECT ROOM_TYPE, listings FROM upper_table", + "VISUALISE ROOM_TYPE AS x, listings AS y DRAW bar" + ) + ) + spec <- execute_ggsql(ds, validated) + expect_s3_class(spec, "Spec") + }) + + it("passes original column names through to ggsql", { + df <- data.frame( + ROOM_TYPE = c("Entire home", "Private room"), + listings = c(10, 20) + ) + ds <- local_data_frame_source(df, table_name = "upper_table") + validated <- list( + sql = "SELECT ROOM_TYPE, listings FROM upper_table", + visual = "VISUALISE ROOM_TYPE AS x, listings AS y DRAW bar" + ) + captured_names <- NULL + + local_mocked_bindings( + duckdb_reader = function(...) "reader", + ggsql_register = function(reader, df, name) { + captured_names <<- names(df) + invisible(NULL) + }, + ggsql_execute = function(reader, query) { + structure(list(), class = "Spec") + }, + .package = "ggsql" + ) + + spec <- execute_ggsql(ds, validated) + expect_s3_class(spec, "Spec") + expect_equal(captured_names, c("ROOM_TYPE", "listings")) + }) + + it("supports FROM before VISUALISE", { + ds <- local_data_frame_source(new_test_df()) + validated <- ggsql::ggsql_validate( + "FROM test_table VISUALISE value AS x DRAW histogram" + ) + expect_true(validated$valid) + expect_true(validated$has_visual) + expect_equal(validated$sql, "SELECT * FROM test_table") + expect_equal(validated$visual, "VISUALISE value AS x DRAW histogram") + + spec <- execute_ggsql(ds, validated) + expect_s3_class(spec, "Spec") + }) + + it("rejects layer-level FROM sources", { + ds <- local_data_frame_source(new_test_df()) + # This is a synthetic test — construct a validated object whose + # visual has a layer-level source + expect_error( + { + validated <- list( + sql = "SELECT * FROM test_table", + visual = "VISUALISE value AS x DRAW point MAPPING x FROM other_table" + ) + execute_ggsql(ds, validated) + }, + "Layer-specific sources" + ) + }) +}) diff --git a/pkg-r/tests/testthat/test-querychat_module.R b/pkg-r/tests/testthat/test-querychat_module.R index 0317541d8..57a2b106f 100644 --- a/pkg-r/tests/testthat/test-querychat_module.R +++ b/pkg-r/tests/testthat/test-querychat_module.R @@ -16,3 +16,116 @@ test_that("Shiny app example loads without errors", { source(test_app_file, local = TRUE) }) }) + +test_that("mod_server() passes visualize callback and tools to client factory", { + skip_if_no_dataframe_engine() + + ds <- local_data_frame_source(new_test_df()) + captured <- NULL + + client_factory <- function(...) { + captured <<- list(...) + structure(list(), class = "MockChat") + } + + shiny::testServer( + mod_server, + args = list( + id = "test", + data_source = ds, + greeting = "Hello", + client = client_factory, + tools = c("query", "visualize"), + enable_bookmarking = FALSE + ), + { + expect_type(captured, "list") + expect_equal(captured$tools, c("query", "visualize")) + expect_true(is.function(captured$visualize)) + expect_true(is.function(captured$update_dashboard)) + expect_true(is.function(captured$reset_dashboard)) + } + ) +}) + +test_that("restored viz widgets survive a second bookmark cycle", { + skip_if_no_dataframe_engine() + + ds <- local_data_frame_source(new_test_df()) + callbacks <- NULL + bookmark_fn <- NULL + restore_fn <- NULL + restored_args <- NULL + + client_factory <- function(...) { + callbacks <<- list(...) + structure(list(), class = "MockChat") + } + + local_mocked_bindings( + chat_restore = function(id, chat, session) {}, + .package = "shinychat" + ) + local_mocked_bindings( + onBookmark = function(fun) { + bookmark_fn <<- fun + }, + onRestore = function(fun) { + restore_fn <<- fun + }, + .package = "shiny" + ) + local_mocked_bindings( + restore_viz_widgets = function(data_source, saved_widgets, session) { + restored_args <<- list( + data_source = data_source, + saved_widgets = saved_widgets, + session = session + ) + saved_widgets + }, + .package = "querychat" + ) + + shiny::testServer( + mod_server, + args = list( + id = "test", + data_source = ds, + greeting = "Hello", + client = client_factory, + tools = c("query", "visualize"), + enable_bookmarking = TRUE + ), + { + expect_true(is.function(bookmark_fn)) + expect_true(is.function(restore_fn)) + expect_true(is.function(callbacks$visualize)) + + saved <- list( + list( + widget_id = "querychat_viz_1", + ggsql = "SELECT 1 VISUALISE 1 AS x DRAW point" + ) + ) + + shiny::isolate(callbacks$visualize(saved[[1]])) + + first_state <- new.env(parent = emptyenv()) + first_state$values <- list() + shiny::isolate(bookmark_fn(first_state)) + expect_equal(first_state$values$querychat_viz_widgets, saved) + + restore_state <- new.env(parent = emptyenv()) + restore_state$values <- first_state$values + shiny::isolate(restore_fn(restore_state)) + expect_identical(restored_args$data_source, ds) + expect_equal(restored_args$saved_widgets, saved) + + second_state <- new.env(parent = emptyenv()) + second_state$values <- list() + shiny::isolate(bookmark_fn(second_state)) + expect_equal(second_state$values$querychat_viz_widgets, saved) + } + ) +}) diff --git a/pkg-r/tests/testthat/test-viz-tool.R b/pkg-r/tests/testthat/test-viz-tool.R new file mode 100644 index 000000000..6356028a3 --- /dev/null +++ b/pkg-r/tests/testthat/test-viz-tool.R @@ -0,0 +1,437 @@ +describe("tool_visualize_dashboard()", { + skip_if_no_dataframe_engine() + skip_if_not_installed("ggsql") + + it("creates a tool with correct name", { + ds <- local_data_frame_source(new_test_df()) + session <- structure( + list( + output = list(), + ns = identity + ), + class = "MockShinySession" + ) + tool <- tool_visualize_dashboard( + ds, + session = session, + update_fn = function(data) {} + ) + expect_equal(tool@name, "querychat_visualize") + }) + + it("renders query fallback guidance only when query tool is enabled", { + ds <- local_data_frame_source(new_test_df()) + session <- structure( + list( + output = list(), + ns = identity + ), + class = "MockShinySession" + ) + + with_query <- tool_visualize_dashboard( + ds, + session = session, + update_fn = function(data) {}, + has_tool_query = TRUE + ) + without_query <- tool_visualize_dashboard( + ds, + session = session, + update_fn = function(data) {}, + has_tool_query = FALSE + ) + + expect_match( + with_query@description, + "use `querychat_query` instead", + fixed = TRUE + ) + expect_no_match( + without_query@description, + "use `querychat_query` instead", + fixed = TRUE + ) + expect_no_match( + without_query@description, + "fall back to `querychat_query`", + fixed = TRUE + ) + }) + + it("describes current ggsql 0.3 visualization rules", { + ds <- local_data_frame_source(new_test_df()) + session <- structure( + list( + output = list(), + ns = identity + ), + class = "MockShinySession" + ) + tool <- tool_visualize_dashboard( + ds, + session = session, + update_fn = function(data) {} + ) + + expect_match( + tool@description, + "All data transformations must happen in the `SELECT` clause.", + fixed = TRUE + ) + expect_match(tool@description, "DRAW range", fixed = TRUE) + expect_no_match( + tool@description, + "using single quotes for strings", + fixed = TRUE + ) + }) + + it("prints the spec and returns a simple result when session is NULL", { + ds <- local_data_frame_source(new_test_df()) + + tool <- tool_visualize_dashboard( + ds, + session = NULL, + update_fn = function(data) {} + ) + + result <- tool( + ggsql = "SELECT * FROM test_table VISUALISE value AS x DRAW histogram", + title = "Test" + ) + + expect_match( + result@value, + "Chart displayed with title 'Test'.", + fixed = TRUE + ) + expect_equal(result@extra, list()) + }) + + it("calls update_fn on success", { + ds <- local_data_frame_source(new_test_df()) + session <- structure( + list( + output = list(), + ns = identity + ), + class = "MockShinySession" + ) + callback_data <- NULL + footer_data <- NULL + local_mocked_bindings( + build_viz_footer = function(...) { + footer_data <<- list(...) + htmltools::tagList() + }, + .package = "querychat" + ) + tool <- tool_visualize_dashboard( + ds, + session = session, + update_fn = function(data) { + callback_data <<- data + } + ) + tool( + ggsql = "SELECT * FROM test_table VISUALISE value AS x DRAW histogram", + title = "Test" + ) + expect_type(callback_data, "list") + expect_true(all(c("ggsql", "title", "widget_id") %in% names(callback_data))) + expect_identical(footer_data$dom_widget_id, footer_data[[3]]) + }) + + it("warns when PNG preview generation fails", { + ds <- local_data_frame_source(new_test_df()) + session <- structure( + list( + output = list(), + ns = identity + ), + class = "MockShinySession" + ) + + local_mocked_bindings( + execute_ggsql = function(...) structure(list(), class = "ggsql_spec"), + build_viz_footer = function(...) htmltools::tagList(), + .package = "querychat" + ) + local_mocked_bindings( + ggsql_validate = function(...) structure(list(valid = TRUE), class = "ggsql_validated"), + ggsql_has_visual = function(...) TRUE, + renderGgsql = function(...) shiny::renderText("ok"), + ggsqlOutput = function(id) htmltools::div(id = id), + ggsql_save = function(...) rlang::abort("V8 is not installed"), + .package = "ggsql" + ) + + tool <- tool_visualize_dashboard( + ds, + session = session, + update_fn = function(data) {} + ) + + expect_warning( + result <- tool( + ggsql = "SELECT * FROM test_table VISUALISE value AS x DRAW histogram", + title = "Test" + ), + "Unable to render PNG preview", + fixed = TRUE + ) + expect_match( + result@value, + "Chart displayed with title 'Test'.", + fixed = TRUE + ) + }) + + it("raises an error for query without VISUALISE", { + ds <- local_data_frame_source(new_test_df()) + session <- structure( + list( + output = list(), + ns = identity + ), + class = "MockShinySession" + ) + tool <- tool_visualize_dashboard( + ds, + session = session, + update_fn = function(data) {} + ) + expect_error( + tool( + ggsql = "SELECT * FROM test_table", + title = "No viz" + ), + "Query must include a VISUALISE clause" + ) + }) + + it("raises an error for bad query", { + ds <- local_data_frame_source(new_test_df()) + session <- structure( + list( + output = list(), + ns = identity + ), + class = "MockShinySession" + ) + tool <- tool_visualize_dashboard( + ds, + session = session, + update_fn = function(data) {} + ) + expect_error( + tool( + ggsql = paste( + "SELECT value AS x, 1 AS y FROM nonexistent_table", + "VISUALISE x AS x, y AS y DRAW point" + ), + title = "Bad" + ), + "Catalog Error" + ) + }) + + it("uses ggsql validation errors and does not execute invalid queries", { + ds <- local_data_frame_source(new_test_df()) + session <- structure( + list( + output = list(), + ns = identity + ), + class = "MockShinySession" + ) + validated <- structure( + list( + valid = FALSE, + errors = data.frame( + message = c("first ggsql error", "second ggsql error") + ) + ), + class = "ggsql_validated" + ) + executed <- FALSE + + local_mocked_bindings( + ggsql_validate = function(...) validated, + ggsql_has_visual = function(...) TRUE, + .package = "ggsql" + ) + local_mocked_bindings( + execute_ggsql = function(...) { + executed <<- TRUE + rlang::abort("execute_ggsql should not be called") + }, + .package = "querychat" + ) + + tool <- tool_visualize_dashboard( + ds, + session = session, + update_fn = function(data) {} + ) + + expect_error( + tool( + ggsql = "SELECT * FROM test_table VISUALISE value AS x DRAW point", + title = "Bad Viz" + ), + "first ggsql error\nsecond ggsql error", + fixed = TRUE + ) + expect_false(executed) + }) + + it("does not fall back to stale QueryChat VISUALISE guidance for invalid ggsql", { + ds <- local_data_frame_source(new_test_df()) + session <- structure( + list( + output = list(), + ns = identity + ), + class = "MockShinySession" + ) + validated <- structure( + list( + valid = FALSE, + errors = data.frame(message = "upstream validation failed") + ), + class = "ggsql_validated" + ) + + local_mocked_bindings( + ggsql_validate = function(...) validated, + ggsql_has_visual = function(...) TRUE, + .package = "ggsql" + ) + + tool <- tool_visualize_dashboard( + ds, + session = session, + update_fn = function(data) {} + ) + + err <- tryCatch( + { + tool( + ggsql = "SELECT * FROM test_table VISUALISE value AS x DRAW point", + title = "Bad Viz" + ) + NULL + }, + error = identity + ) + + expect_s3_class(err, "error") + expect_match( + conditionMessage(err), + "upstream validation failed", + fixed = TRUE + ) + expect_no_match( + conditionMessage(err), + "VISUALISE clause was not recognized", + fixed = TRUE + ) + }) + + it("lets visualize_result() errors bubble up unchanged", { + ds <- local_data_frame_source(new_test_df()) + long_msg <- paste(rep("word", 200), collapse = " ") + session <- structure( + list( + output = list(), + ns = identity + ), + class = "MockShinySession" + ) + + local_mocked_bindings( + visualize_result = function(...) { + rlang::abort(long_msg) + }, + .package = "querychat" + ) + + impl <- tool_visualize_impl( + ds, + session = session, + update_fn = function(data) {} + ) + expect_error( + impl( + ggsql = "SELECT * FROM test_table VISUALISE value AS x DRAW histogram", + title = "Bad" + ), + long_msg, + fixed = TRUE + ) + }) +}) + +describe("collapse_validation_errors()", { + it("joins multiple upstream validation messages", { + validated <- structure( + list( + errors = data.frame( + message = c("first ggsql error", "second ggsql error") + ) + ), + class = "ggsql_validated" + ) + + expect_equal( + collapse_validation_errors(validated), + "first ggsql error\nsecond ggsql error" + ) + }) + + it("falls back when no validation messages are available", { + validated <- structure( + list( + errors = data.frame(message = character()) + ), + class = "ggsql_validated" + ) + + expect_equal( + collapse_validation_errors(validated), + "Invalid ggsql query." + ) + }) + it("passes the namespaced DOM id into the footer", { + ds <- local_data_frame_source(new_test_df()) + session <- structure( + list( + output = list(), + ns = function(id) paste0("repro-", id) + ), + class = "MockShinySession" + ) + footer_data <- NULL + local_mocked_bindings( + build_viz_footer = function(...) { + footer_data <<- list(...) + htmltools::tagList() + }, + .package = "querychat" + ) + tool <- tool_visualize_dashboard( + ds, + session = session, + update_fn = function(data) {} + ) + + tool( + ggsql = "SELECT * FROM test_table VISUALISE value AS x DRAW histogram", + title = "Test" + ) + + expect_identical(footer_data$dom_widget_id, paste0("repro-", footer_data[[3]])) + }) +}) From 9f36c572f01c1711ce3a28a4d657e37b3c6822f3 Mon Sep 17 00:00:00 2001 From: Carson Date: Fri, 1 May 2026 17:36:14 -0500 Subject: [PATCH 2/4] fix(pkg-r): collect tbl_sql before passing to ggsql_register For TblSqlSource, execute_query() returns a lazy tbl_sql which ggsql_register() can't handle. Materialize it first, matching the existing pattern in app_obj(). --- pkg-r/R/querychat_viz.R | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pkg-r/R/querychat_viz.R b/pkg-r/R/querychat_viz.R index 4ae560ef1..8f6fff46d 100644 --- a/pkg-r/R/querychat_viz.R +++ b/pkg-r/R/querychat_viz.R @@ -298,6 +298,11 @@ execute_ggsql <- function(data_source, validated) { df <- data_source$execute_query(validated$sql) + if (inherits(df, "tbl_sql")) { + # Materialize the query for ggsql, {dplyr} guaranteed by TblSqlSource + df <- dplyr::collect(df) + } + reader <- ggsql::duckdb_reader() table <- extract_visualise_table(visual) From 2f32d28c4ad540ef2fc69ea3357048aa609f3eb7 Mon Sep 17 00:00:00 2001 From: Carson Date: Mon, 4 May 2026 10:28:22 -0500 Subject: [PATCH 3/4] docs(pkg-r): add visualization documentation Add a new Visualizations vignette, a Data visualization section to the Tools vignette, a navbar entry in pkgdown, and a mention in the README, mirroring the documentation added for the Python package in PR #201. --- pkg-r/README.md | 4 + pkg-r/pkgdown/_pkgdown.yml | 2 + pkg-r/vignettes/tools.Rmd | 39 ++++++++- pkg-r/vignettes/visualize.Rmd | 144 ++++++++++++++++++++++++++++++++++ 4 files changed, 188 insertions(+), 1 deletion(-) create mode 100644 pkg-r/vignettes/visualize.Rmd diff --git a/pkg-r/README.md b/pkg-r/README.md index d6f70fa0a..3cf35d07f 100644 --- a/pkg-r/README.md +++ b/pkg-r/README.md @@ -52,6 +52,9 @@ querychat can also handle more general questions about the data that require cal ![](man/figures/quickstart-summary.png){alt="Screenshot of the querychat's app with a summary statistic inlined in the chat." class="rounded shadow"} +querychat can also create visualizations, powered by [ggsql](https://ggsql.org/). +With the [visualization tool](https://posit-dev.github.io/querychat/r/articles/visualize.html) enabled, ask for a chart and it appears inline in the conversation. + ## Custom apps querychat is designed to be highly extensible -- it provides programmatic access to the chat interface, the filtered/sorted data frame, SQL queries, and more. @@ -93,6 +96,7 @@ From here, you might want to learn more about: - [Models](https://posit-dev.github.io/querychat/r/articles/models.html): customize the LLM behind querychat. - [Data sources](https://posit-dev.github.io/querychat/r/articles/data-sources.html): different data sources you can use with querychat. - [Provide context](https://posit-dev.github.io/querychat/r/articles/context.html): provide the LLM with the context it needs to work well. +- [Visualizations](https://posit-dev.github.io/querychat/r/articles/visualize.html): create inline charts powered by ggsql. - [Build an app](https://posit-dev.github.io/querychat/r/articles/build.html): design a custom Shiny app around querychat. - [Greet users](https://posit-dev.github.io/querychat/r/articles/greet.html): create welcoming onboarding experiences. - [Tools](https://posit-dev.github.io/querychat/r/articles/tools.html): understand what querychat can do under the hood. diff --git a/pkg-r/pkgdown/_pkgdown.yml b/pkg-r/pkgdown/_pkgdown.yml index a2adba09e..e76151f42 100644 --- a/pkg-r/pkgdown/_pkgdown.yml +++ b/pkg-r/pkgdown/_pkgdown.yml @@ -51,6 +51,8 @@ navbar: href: articles/data-sources.html - text: Provide context href: articles/context.html + - text: Visualizations + href: articles/visualize.html - text: Build an app href: articles/build.html - text: Greet users diff --git a/pkg-r/vignettes/tools.Rmd b/pkg-r/vignettes/tools.Rmd index 46454042e..ab5cc24df 100644 --- a/pkg-r/vignettes/tools.Rmd +++ b/pkg-r/vignettes/tools.Rmd @@ -19,10 +19,11 @@ querychat combines [tool calling](https://ellmer.tidyverse.org/articles/tool-cal One important thing to understand generally about querychat's tools is they are R functions, and that execution happens on _your machine_, not on the LLM provider's side. In other words, the SQL queries generated by the LLM are executed locally in the R process running the app. -querychat provides the LLM access to two tool groups: +querychat provides the LLM access to three tool groups: 1. **Data updating** - Filter and sort data (without sending results to the LLM). 2. **Data analysis** - Calculate summaries and return results for interpretation by the LLM. +3. **Data visualization** - Create charts inline in the chat. ```{r} library(querychat) @@ -61,6 +62,40 @@ querychat_app(penguins) ![](../reference/figures/quickstart-summary.png){alt="Screenshot of the querychat's app with a summary statistic inlined in the chat." class="shadow rounded"} +## Data visualization + +When a user asks for a chart or visualization, the LLM generates a [ggsql](https://ggsql.org/) query — standard SQL extended with a `VISUALISE` clause — and requests a call to the `visualize` tool. +This tool: + +1. Executes the SQL portion of the query +2. Renders the `VISUALISE` clause as an interactive chart +3. Displays the chart inline in the chat + +Unlike the data updating tools, visualization queries don't affect the dashboard filter. +They query the full dataset independently, and each call produces a new inline chart message in the chat. + +The inline chart includes controls for fullscreen viewing, saving as PNG/SVG, and a "Show Query" toggle that reveals the underlying ggsql code. + +To use the visualization tool, first install the ggsql package: + +```r +pak::pak("posit-dev/ggsql-r") +``` + +Then include `"visualize"` in the `tools` parameter (it is not enabled by default): + +```{r} +library(palmerpenguins) + +qc <- QueryChat$new( + penguins, + tools = c("query", "update", "visualize") +) +qc$app() +``` + +See [Visualizations](visualize.html) for more details. + ## View the source If you'd like to better understand how the tools work and how the LLM is prompted to use them, check out the following resources: @@ -68,9 +103,11 @@ If you'd like to better understand how the tools work and how the LLM is prompte **Source code:** - [`querychat_tools.R`](https://github.com/posit-dev/querychat/blob/main/pkg-r/R/querychat_tools.R) +- [`querychat_viz.R`](https://github.com/posit-dev/querychat/blob/main/pkg-r/R/querychat_viz.R) **Prompts:** - [`prompts/tool-update-dashboard.md`](https://github.com/posit-dev/querychat/blob/main/pkg-r/inst/prompts/tool-update-dashboard.md) - [`prompts/tool-reset-dashboard.md`](https://github.com/posit-dev/querychat/blob/main/pkg-r/inst/prompts/tool-reset-dashboard.md) - [`prompts/tool-query.md`](https://github.com/posit-dev/querychat/blob/main/pkg-r/inst/prompts/tool-query.md) +- [`prompts/tool-visualize.md`](https://github.com/posit-dev/querychat/blob/main/pkg-r/inst/prompts/tool-visualize.md) diff --git a/pkg-r/vignettes/visualize.Rmd b/pkg-r/vignettes/visualize.Rmd new file mode 100644 index 000000000..75279d3e3 --- /dev/null +++ b/pkg-r/vignettes/visualize.Rmd @@ -0,0 +1,144 @@ +--- +title: "Visualizations" +output: rmarkdown::html_vignette +vignette: > + %\VignetteIndexEntry{Visualizations} + %\VignetteEngine{knitr::rmarkdown} + %\VignetteEncoding{UTF-8} +--- + +```{r, include = FALSE} +knitr::opts_chunk$set( + collapse = TRUE, + comment = "#>", + eval = FALSE +) +``` + +querychat can create charts inline in the chat. +When you ask a question that benefits from a visualization, the LLM writes a query using [ggsql](https://ggsql.org/) — a SQL-like visualization grammar — and renders an interactive chart directly in the conversation. + +## Getting started + +Visualization requires two steps: + +1. **Install the ggsql package:** + + ```r + pak::pak("posit-dev/ggsql-r") + ``` + +2. **Include `"visualize"` in the `tools` parameter:** + + ```r + library(querychat) + library(palmerpenguins) + + qc <- QueryChat$new( + penguins, + tools = c("query", "update", "visualize") + ) + qc$app() + ``` + +Ask something like "Show me body mass by species as a bar chart" and querychat will generate and display the chart inline. + +## Choosing tools + +The `tools` parameter controls which capabilities the LLM has access to. +By default, only `"query"` and `"update"` are enabled — visualization must be opted into explicitly. + +To enable only query and visualization (no dashboard filtering): + +```r +qc <- QueryChat$new( + penguins, + tools = c("query", "visualize") +) +``` + +See [Tools](tools.html) for a full reference on available tools and what each one does. + +## Custom apps + +The example below shows a custom Shiny app with visualization enabled. + +```r +library(shiny) +library(bslib) +library(querychat) +library(palmerpenguins) + +qc <- QueryChat$new( + penguins, + tools = c("update", "query", "visualize"), + data_description = paste( + "The Palmer Penguins dataset contains measurements of bill", + "dimensions, flipper length, body mass, sex, and species", + "(Adelie, Chinstrap, and Gentoo) collected from three islands in", + "the Palmer Archipelago, Antarctica." + ) +) + +ui <- page_sidebar( + title = "querychat viz demo", + sidebar = qc$sidebar(width = 400), + card( + full_screen = TRUE, + card_header("Data"), + DT::DTOutput("dt") + ) +) + +server <- function(input, output, session) { + qc_vals <- qc$server() + output$dt <- DT::renderDT(qc_vals$df(), fillContainer = TRUE) +} + +shinyApp(ui, server) +``` + +## What you can ask for + +querychat can generate a wide range of chart types. +Some example prompts: + +- "Show me a bar chart of body mass by species" +- "Scatter plot of bill length vs flipper length, colored by species" +- "Line chart of average body mass over time" +- "Histogram of bill depths" +- "Facet flipper length by island and species" + +The LLM chooses an appropriate chart type based on your question, but you can always be specific. +If you ask for a bar chart, you'll get a bar chart. + +::: {.alert .alert-info} +If you don't like the chart, ask the LLM to adjust it — for example, "make the dots bigger" or "use a log scale on the y-axis". +::: + +## Chart controls + +Each chart has controls in its footer: + +**Fullscreen** — Click the expand icon to view the chart in fullscreen mode. + +**Save** — Download the chart as a PNG or SVG file. + +**Show Query** — Expand the footer to see the ggsql query used to generate the chart. + +## How it works + +1. **The LLM generates a ggsql query** — a SQL-like grammar that describes both data transformation and visual encoding in a single statement. +2. **The SQL is executed** — querychat runs the data portion of the query against your data source locally. +3. **The VISUALISE clause is rendered** — the result is passed to a ggsql reader, which produces an interactive chart. +4. **The chart appears inline** — the chart is rendered in the conversation as an interactive widget. + +Note that visualization queries are independent of any active dashboard filter set by the `update` tool. +They always run against the full dataset. + +Learn more about the ggsql grammar at [ggsql.org](https://ggsql.org/). + +## See also + +- [Tools](tools.html) — Understand what querychat can do under the hood +- [Provide context](context.html) — Help the LLM understand your data better From 8b156c0ef9b95b297bd1a0c36c7018c3dc9f8ce8 Mon Sep 17 00:00:00 2001 From: Carson Date: Mon, 4 May 2026 11:13:38 -0500 Subject: [PATCH 4/4] docs(pkg-r): add visualization screenshots to docs Add screenshots for bar chart, scatter plot, fullscreen, and show-query views. Wire them into the Visualizations vignette and the README. --- pkg-r/README.md | 4 +++- pkg-r/man/figures/viz-bar-chart.png | Bin 0 -> 16957 bytes pkg-r/man/figures/viz-fullscreen.png | Bin 0 -> 108891 bytes pkg-r/man/figures/viz-scatter.png | Bin 0 -> 49172 bytes pkg-r/man/figures/viz-show-query.png | Bin 0 -> 40231 bytes pkg-r/vignettes/visualize.Rmd | 10 +++++++++- 6 files changed, 12 insertions(+), 2 deletions(-) create mode 100644 pkg-r/man/figures/viz-bar-chart.png create mode 100644 pkg-r/man/figures/viz-fullscreen.png create mode 100644 pkg-r/man/figures/viz-scatter.png create mode 100644 pkg-r/man/figures/viz-show-query.png diff --git a/pkg-r/README.md b/pkg-r/README.md index 3cf35d07f..ca99f97fb 100644 --- a/pkg-r/README.md +++ b/pkg-r/README.md @@ -53,7 +53,9 @@ querychat can also handle more general questions about the data that require cal ![](man/figures/quickstart-summary.png){alt="Screenshot of the querychat's app with a summary statistic inlined in the chat." class="rounded shadow"} querychat can also create visualizations, powered by [ggsql](https://ggsql.org/). -With the [visualization tool](https://posit-dev.github.io/querychat/r/articles/visualize.html) enabled, ask for a chart and it appears inline in the conversation. +With the [visualization tool](https://posit-dev.github.io/querychat/r/articles/visualize.html) enabled, ask for a chart and it appears inline in the conversation: + +![](man/figures/viz-bar-chart.png){alt="Bar chart showing average body mass by penguin species." class="rounded shadow"} ## Custom apps diff --git a/pkg-r/man/figures/viz-bar-chart.png b/pkg-r/man/figures/viz-bar-chart.png new file mode 100644 index 0000000000000000000000000000000000000000..76708124b0bdce6a37c85374707046d4aacd991d GIT binary patch literal 16957 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 p_mm0av|9!%4C{fz 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⪻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 literal 0 HcmV?d00001 diff --git a/pkg-r/man/figures/viz-show-query.png b/pkg-r/man/figures/viz-show-query.png new file mode 100644 index 0000000000000000000000000000000000000000..6b8f69c91e05d978026731be1ae2ee1544848478 GIT binary patch literal 40231 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 SrxU6G0000