How do I set different chunk options for different language code chunks, e.g., R and SQL in a single document.

[rressler]

Description

I have a document with sql and R code chunks and I would like to set different code chunk options for each language. Both Bing Copilot and meta.ai suggest using the execute function in the yaml header as below. While the document renders fine, the chunk options seemed to be ignored by knitr.
Appreciate any suggestions.

---
execute:
  sql:
    echo: fenced
  r:
    echo: true
---

```{r}
#| label: createData
#| message: false
library(DBI)
library(duckdb)
library(nycflights13)
library(tidyverse)
```

```{r}
#| label: make-connection
con <- dbConnect(duckdb(dbdir = "./data/flights.duckdb", read_only = TRUE))
class(con)
```

```{sql}
#| connection: con
SHOW TABLES;
```

```{r}
names(flights)
```

[cscheid]

Both Bing Copilot and meta.ai suggest using the execute function in the yaml header as below

Before anything else, I really do strongly recommend that you don't rely on LLMs for Quarto information: they tend to use old crawls that happened before Quarto, and confuse Quarto and RMarkdown on a regular basis.

[rressler]

Absolutely Agree. It is always a multi-step process to try to get something reasonable and even then it may not work. In this case, it does not seem to but thought I would check for alternatives. Thanks From: Carlos Scheidegger ***@***.***> Date: Monday, May 13, 2024 at 4:36 PM To: quarto-dev/quarto-cli ***@***.***> Cc: Richard Ressler ***@***.***>, Author ***@***.***> Subject: Re: [quarto-dev/quarto-cli] How do I set different chunk options for different language code chunks, e.g., R and SQL in a single document. (Discussion #9656) External Email: Use caution with links and attachments. Both Bing Copilot and meta.ai suggest using the execute function in the yaml header as below Before anything else, I really do strongly recommend that you don't rely on LLMs for Quarto information: they tend to use old crawls that happened before Quarto, and confuse Quarto and RMarkdown on a regular basis. — Reply to this email directly, view it on GitHub<https://urldefense.com/v3/__https:/github.com/quarto-dev/quarto-cli/discussions/9656*discussioncomment-9425790__;Iw!!IaT_gp1N!z8G3qLLyvmPGVhx5DRymIgmsdIl1GuchwGks1nUthScNEscEVrwyu_ACH3HyeoUHcb55U4LQdp2Ju7-kXvnQuTN8uPQ$>, or unsubscribe<https://urldefense.com/v3/__https:/github.com/notifications/unsubscribe-auth/AOCMN3O73XHGW6HX466HAFLZCEP4BAVCNFSM6AAAAABHU3T3R6VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TIMRVG44TA__;!!IaT_gp1N!z8G3qLLyvmPGVhx5DRymIgmsdIl1GuchwGks1nUthScNEscEVrwyu_ACH3HyeoUHcb55U4LQdp2Ju7-kXvnQE3ZWtI4$>. You are receiving this because you authored the thread.Message ID: ***@***.***>

[mcanouil]

Better to look in the documentation rather than trust LLM.
See https://quarto.org/docs/computations/execution-options.html where executing options are described.

For short, the suggestion is completely wrong and there is currently no way (natively) to do what you want.
It might be possible using a LUA filter.

PS: when you reply by email, don't include the original message: everything is posted (emails are still obfuscated), thus your actual message is "hidden" amongst all the elements of an email.

[rressler]

Thank for the response.
I have looked at several pieces of documentation as I thought I could use knitr option hooks as in https://stackoverflow.com/questions/76732162/is-there-a-way-to-detect-the-chunk-language-when-setting-knitr-chunk-options.

It works for echo true and false but not for fenced as it is not a logical.

I used
knitr:
opts_chunk:
echo: fenced

to set the default to fenced and then tried to just set it to TRUE for non-SQL engines. However the following fails if the default is set to fenced as above.

knitr::opts_hooks$set(
  echo = function(options) {
    if (options$engine != "sql") {
      options$echo <- TRUE
    }
    return(options)
  }
)

with error
Error in length(options$echo) > 1L || options$echo:
! invalid 'y' type in 'x || y'
Backtrace:

1. global .main()
2. execute(...)
3. rmarkdown::render(...)
4. knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
5. knitr:::process_file(text, output)
   ...
6. knitr:::block_exec(params)
7. knitr (local) engine(options)
8. knitr::engine_output(options, query, output)
9. knitr:::one_string(...)
10. base::paste(x, ..., collapse = "\n")

[mcanouil]

fenced is a Quarto option value agnostic to the language.

If you want to go the R specific way via knitr, then you should look at knitr documentation: https://yihui.org/knitr/options/.

[rressler]

Thanks. I was able to find in quarto hooks.R how Quarto is creating echo.fenced as a non-knitr option where it sets echo=TRUE and constructs the "fenced code" chunk before passing to knitr which is how it gets around the knitr expectation of echo as a logical. Thus the presence of fenced is handled by quarto in a way that seems to be undetectable by knitr. Learning more each day, Thanks!

[cderv]

Yes fenced is a special value handled by Quarto, and it does it in option hooks. So if you want to leverage that from knitr, several things need to be taken into account

I used

knitr:
    opts_chunk:
        echo: fenced

This works well to set as a default fenced for every chunks. This is a good way to set it.

Though, when then you do

knitr::opts_hooks$set(
  echo = function(options) {
    if (options$engine != "sql") {
      options$echo <- TRUE
    }
    return(options)
  }
)

you are overwriting any other hooks that are set by any other tools, including Quarto. So echo = "fenced" will not work well.
When modifying hooks, best advice is to think about potential set hooks and get them before changing.

local({
  ## Get hooks already defined
  oo <- knitr::opts_hooks$get("echo")
  ## Add hooks
  knitr::opts_hooks$set(
    echo = function(options) {
      if (options$engine == "sql") {
        options$echo <- TRUE
      }
      return(oo(options))
    }
  )
})

Above

1. We get the current option hook for echo
2. We do our modification for sql engine chunk
3. We apply the usual hook after that

This would work to change echo to TRUE for SQL chunk.

So you were close to make it work. Try the above and it should be ok.

Though, if you use the other execute syntax common to Jupyter, that it is not enough. Because if you do this to set fenced as a default for all

execute:
   echo: fenced

this is setting an internal option fenced.echo and so you would need to change it back for sql . No way to know it without reading code.

Adding this would work for what you want

```{r}
local({
  ## Get hooks already defined
  oo <- knitr::opts_hooks$get("echo")
  ## Add hooks
  knitr::opts_hooks$set(
    echo = function(options) {
      if (options$engine == "sql") {
        options$echo <- TRUE
        options$fenced.echo <- FALSE
      }
      return(oo(options))
    }
  )
})
```

You could also set fenced as a default from the hook itself

```{r}
local({
  ## Get hooks already defined
  oo <- knitr::opts_hooks$get("echo")
  ## Add hooks
  knitr::opts_hooks$set(
    echo = function(options) {
      if (options$engine == "sql") {
        options$echo <- TRUE
      } else {
        options$echo <- "fenced"
      }
      return(oo(options))
    }
  )
})
```

But it would apply only for chunks after this one.

Anyhow, I hope it clarifies.

This is advanced knitr but I wanted to correct what was said: It is detectable. Quarto only leverage knitr features and highly customize it.

[mcanouil]

There is also an alternative depending on the option to use Lua filter:

• Typst: Is it possible to rotate output from quarto? #9705 (reply in thread)
• How can I use a pre-render approach with a Lua document filter? #9646 (reply in thread)

[cderv]

I have a document with sql and R code chunks and I would like to set different code chunk options for each language.

Using Options hooks seems the right way

• https://bookdown.org/yihui/rmarkdown-cookbook/option-hooks.html

Just in Quarto context, making sure to not overwrite is important (discussed in #9656 (reply in thread)) as Quarto could use hooks for some options already and you don't want to overwrite those (🤔 I am thinking we should try to protect against that maybe... )

Using Options template is another feature that can be useful

• https://bookdown.org/yihui/rmarkdown-cookbook/opts-template.html

You could then use opts-label option in all your sql chunk to change the default.

Example with what you needed above

---
title: test
knitr:
  opts_chunk: 
    echo: fenced
---

```{r}
#| label: createData
#| message: false
library(DBI)
```

```{r}
knitr::opts_template$set(sqlopts = list(echo = FALSE, connection = "con"))
```

```{r}
#| label: make-connection
con <- dbConnect(RSQLite::SQLite(), dbname = ":memory:")
dbWriteTable(con, "mtcars", mtcars)
```

```{sql}
#| opts-label: sqlopts
SELECT * FROM mtcars WHERE cyl = 4
```

```{r}
mtcars[mtcars$cyl == 4,]
```

The SQL chunk won't show.

This is really not Quarto specific - just some knitr features, adapted in Quarto context.