Avoid link at EOL

R/spec-arrow-append-table-arrow.R

@@ -67,9 +67,9 @@ spec_arrow_append_table_arrow <- list(
   arrow_append_table_arrow_error = function(con, table_name) {
     #' An error is also raised
     test_in <- stream_frame(a = 1L)
-    #' if `name` cannot be processed with [dbQuoteIdentifier()]
+    #' if `name` cannot be processed with [dbQuoteIdentifier()] or
     expect_error(dbAppendTableArrow(con, NA, test_in))
-    #' or if this results in a non-scalar.
+    #' if this results in a non-scalar.
     expect_error(dbAppendTableArrow(con, c("test", "test"), test_in))
   },
 

R/spec-arrow-create-table-arrow.R

@@ -45,9 +45,9 @@ spec_arrow_create_table_arrow <- list(
   arrow_create_table_arrow_error = function(ctx, con, table_name) {
     #' An error is also raised
     test_in <- stream_frame(a = 1L)
-    #' if `name` cannot be processed with [dbQuoteIdentifier()]
+    #' if `name` cannot be processed with [dbQuoteIdentifier()] or
     expect_error(dbCreateTableArrow(con, NA, test_in))
-    #' or if this results in a non-scalar.
+    #' if this results in a non-scalar.
     expect_error(dbCreateTableArrow(con, c(table_name, table_name), test_in))
 
     #' Invalid values for the `temporary` argument

R/spec-arrow-fetch-arrow-chunk.R

@@ -11,8 +11,8 @@ spec_arrow_fetch_arrow_chunk <- list(
 
   arrow_fetch_arrow_chunk_atomic = function(con) {
     #' @return
-    #' `dbFetchArrowChunk()` always returns an object coercible to a [data.frame]
-    #' with as many rows as records were fetched and as many
+    #' `dbFetchArrowChunk()` always returns an object coercible to a [data.frame] with
+    #' as many rows as records were fetched and as many
     #' columns as fields in the result set,
     #' even if the result is a single value
     query <- trivial_query()

R/spec-arrow-fetch-arrow.R

@@ -11,8 +11,8 @@ spec_arrow_fetch_arrow <- list(
 
   arrow_fetch_arrow_atomic = function(con) {
     #' @return
-    #' `dbFetchArrow()` always returns an object coercible to a [data.frame]
-    #' with as many rows as records were fetched and as many
+    #' `dbFetchArrow()` always returns an object coercible to a [data.frame] with
+    #' as many rows as records were fetched and as many
     #' columns as fields in the result set,
     #' even if the result is a single value
     query <- trivial_query()

R/spec-arrow-read-table-arrow.R

@@ -15,8 +15,8 @@ spec_arrow_read_table_arrow <- list(
 
     #' @return
     #' `dbReadTableArrow()` returns an Arrow object that contains the complete data
-    #' from the remote table, effectively the result of calling [dbGetQueryArrow()]
-    #' with `SELECT * FROM <name>`.
+    #' from the remote table, effectively the result of calling [dbGetQueryArrow()] with
+    #' `SELECT * FROM <name>`.
     penguins_in <- get_penguins(ctx)
     dbWriteTable(con, table_name, penguins_in)
     penguins_out <- check_arrow(dbReadTableArrow(con, table_name))
@@ -63,9 +63,9 @@ spec_arrow_read_table_arrow <- list(
   arrow_read_table_arrow_error = function(ctx, con, table_name) {
     #' An error is raised
     dbWriteTable(con, table_name, data.frame(a = 1.5))
-    #' if `name` cannot be processed with [dbQuoteIdentifier()]
+    #' if `name` cannot be processed with [dbQuoteIdentifier()] or
     expect_error(dbReadTableArrow(con, NA))
-    #' or if this results in a non-scalar.
+    #' if this results in a non-scalar.
     expect_error(dbReadTableArrow(con, c(table_name, table_name)))
   },
 

R/spec-arrow-write-table-arrow.R

@@ -58,9 +58,9 @@ spec_arrow_write_table_arrow <- list(
 
     #' An error is also raised
     test_in <- stream_frame(a = 1L)
-    #' if `name` cannot be processed with [dbQuoteIdentifier()]
+    #' if `name` cannot be processed with [dbQuoteIdentifier()] or
     expect_error(dbWriteTableArrow(con, NA, test_in %>% stream_frame()))
-    #' or if this results in a non-scalar.
+    #' if this results in a non-scalar.
     expect_error(dbWriteTableArrow(con, c(table_name, table_name), test_in %>% stream_frame()))
 
     #' Invalid values for the additional arguments

R/spec-driver-constructor.R

@@ -8,8 +8,7 @@ spec_driver_constructor <- list(
   constructor = function(ctx) {
     pkg_name <- package_name(ctx)
 
-    #' The backend must support creation of an instance of its [DBIDriver-class]
-    #' subclass
+    #' The backend must support creation of an instance of its [DBIDriver-class] subclass
     #' with a \dfn{constructor function}.
     #' By default, its name is the package name without the leading \sQuote{R}
     #' (if it exists), e.g., `SQLite` for the \pkg{RSQLite} package.

R/spec-driver-data-type.R

@@ -113,12 +113,12 @@ test_data_type <- function(ctx, dbObj) {
     }
   )
 
-  #' The SQL data type for [factor]
+  #' The SQL data type for [factor] and
   expect_identical(
     dbDataType(dbObj, letters),
     dbDataType(dbObj, factor(letters))
   )
-  #' and [ordered] is the same as for character.
+  #' [ordered] is the same as for character.
   expect_identical(
     dbDataType(dbObj, letters),
     dbDataType(dbObj, ordered(letters))

R/spec-meta-bind-expr.R

@@ -24,7 +24,7 @@ spec_meta_bind_expr <- function(
         expect_false(bind_res$visible)
       }
 
-      #' for queries issued by [dbSendQuery()] or [dbSendQueryArrow()]
+      #' for queries issued by [dbSendQuery()] or [dbSendQueryArrow()] and
       test_select_bind_expr(
         arrow = arrow,
         bind = bind,
@@ -39,7 +39,7 @@ spec_meta_bind_expr <- function(
         expect_false(bind_res$visible)
       }
 
-      #' and also for data manipulation statements issued by
+      #' also for data manipulation statements issued by
       #' [dbSendStatement()].
       test_select_bind_expr(
         arrow = arrow,

R/spec-meta-get-statement.R

@@ -13,7 +13,7 @@ spec_meta_get_statement <- list(
     #' @return
     #' `dbGetStatement()` returns a string, the query used in
     query <- trivial_query()
-    #' either [dbSendQuery()]
+    #' either [dbSendQuery()] or
     res <- local_result(dbSendQuery(con, query))
     s <- dbGetStatement(res)
     expect_type(s, "character")
@@ -22,7 +22,7 @@ spec_meta_get_statement <- list(
   #
   get_statement_statement = function(con, table_name) {
     query <- paste0("CREATE TABLE ", table_name, " (a integer)")
-    #' or [dbSendStatement()].
+    #' [dbSendStatement()].
     res <- local_result(dbSendStatement(con, query))
     s <- dbGetStatement(res)
     expect_type(s, "character")

R/spec-result-fetch.R

@@ -11,8 +11,8 @@ spec_result_fetch <- list(
 
   fetch_atomic = function(con) {
     #' @return
-    #' `dbFetch()` always returns a [data.frame]
-    #' with as many rows as records were fetched and as many
+    #' `dbFetch()` always returns a [data.frame] with
+    #' as many rows as records were fetched and as many
     #' columns as fields in the result set,
     #' even if the result is a single value
     query <- trivial_query()
@@ -87,8 +87,8 @@ spec_result_fetch <- list(
   fetch_no_return_value = function(con, table_name) {
     #'
     #' Calling `dbFetch()` on a result set from a data manipulation query
-    #' created by [dbSendStatement()]
-    #' can be fetched and return an empty data frame, with a warning.
+    #' created by [dbSendStatement()] can
+    #' be fetched and return an empty data frame, with a warning.
     query <- paste0("CREATE TABLE ", table_name, " (a integer)")
 
     res <- local_result(dbSendStatement(con, query))
@@ -124,11 +124,11 @@ spec_result_fetch <- list(
     result <- trivial_df(25)
 
     res <- local_result(dbSendQuery(con, query))
-    #' by passing a whole number ([integer]
+    #' by passing a whole number ([integer] or
     rows <- check_df(dbFetch(res, 10L))
     expect_identical(rows, unrowname(result[1:10, , drop = FALSE]))
 
-    #' or [numeric])
+    #' [numeric])
     rows <- check_df(dbFetch(res, 10))
     expect_identical(rows, unrowname(result[11:20, , drop = FALSE]))
 

R/spec-sql-append-table.R

@@ -64,9 +64,9 @@ spec_sql_append_table <- list(
   append_table_error = function(con, table_name) {
     #' An error is also raised
     test_in <- data.frame(a = 1L)
-    #' if `name` cannot be processed with [dbQuoteIdentifier()]
+    #' if `name` cannot be processed with [dbQuoteIdentifier()] or
     expect_error(dbAppendTable(con, NA, test_in))
-    #' or if this results in a non-scalar.
+    #' if this results in a non-scalar.
     expect_error(dbAppendTable(con, c("test", "test"), test_in))
 
     #' Invalid values for the `row.names` argument

R/spec-sql-create-table.R

@@ -43,9 +43,9 @@ spec_sql_create_table <- list(
   create_table_error = function(ctx, con, table_name) {
     #' An error is also raised
     test_in <- data.frame(a = 1L)
-    #' if `name` cannot be processed with [dbQuoteIdentifier()]
+    #' if `name` cannot be processed with [dbQuoteIdentifier()] or
     expect_error(dbCreateTable(con, NA, test_in))
-    #' or if this results in a non-scalar.
+    #' if this results in a non-scalar.
     expect_error(dbCreateTable(con, c(table_name, table_name), test_in))
 
     #' Invalid values for the `row.names` and `temporary` arguments

R/spec-sql-exists-table.R

@@ -51,9 +51,9 @@ spec_sql_exists_table <- list(
   exists_table_error = function(con, table_name) {
     #' An error is also raised
     dbWriteTable(con, table_name, data.frame(a = 1L))
-    #' if `name` cannot be processed with [dbQuoteIdentifier()]
+    #' if `name` cannot be processed with [dbQuoteIdentifier()] or
     expect_error(dbExistsTable(con, NA))
-    #' or if this results in a non-scalar.
+    #' if this results in a non-scalar.
     expect_error(dbExistsTable(con, c(table_name, table_name)))
   },
 

R/spec-sql-list-objects.R

@@ -37,11 +37,11 @@ spec_sql_list_objects <- list(
     #' accessible from the prefix (if passed) or from the global namespace
     #' (if prefix is omitted).
 
-    #' Tables added with [dbWriteTable()]
+    #' Tables added with [dbWriteTable()] are
     penguins <- get_penguins(ctx)
     dbWriteTable(con, table_name, penguins)
 
-    #' are part of the data frame.
+    #' part of the data frame.
     objects <- dbListObjects(con)
     quoted_tables <- vapply(objects$table, dbQuoteIdentifier, conn = con, character(1))
     expect_true(dbQuoteIdentifier(con, table_name) %in% quoted_tables)

R/spec-sql-list-tables.R

@@ -22,11 +22,11 @@ spec_sql_list_tables <- list(
     # TODO
     #' in the database.
 
-    #' Tables added with [dbWriteTable()]
+    #' Tables added with [dbWriteTable()] are
     penguins <- get_penguins(ctx)
     dbWriteTable(con, table_name, penguins)
 
-    #' are part of the list.
+    #' part of the list.
     tables <- dbListTables(con)
     expect_true(table_name %in% tables)
   },

R/spec-sql-read-table.R

@@ -12,8 +12,8 @@ spec_sql_read_table <- list(
   read_table = function(ctx, con, table_name) {
     #' @return
     #' `dbReadTable()` returns a data frame that contains the complete data
-    #' from the remote table, effectively the result of calling [dbGetQuery()]
-    #' with `SELECT * FROM <name>`.
+    #' from the remote table, effectively the result of calling [dbGetQuery()] with
+    #' `SELECT * FROM <name>`.
     penguins_in <- get_penguins(ctx)
     dbWriteTable(con, table_name, penguins_in)
     penguins_out <- check_df(dbReadTable(con, table_name))

R/spec-sql-remove-table.R

@@ -45,9 +45,9 @@ spec_sql_remove_table <- list(
   remove_table_error = function(con, table_name) {
     #' An error is also raised
     dbWriteTable(con, table_name, data.frame(a = 1L))
-    #' if `name` cannot be processed with [dbQuoteIdentifier()]
+    #' if `name` cannot be processed with [dbQuoteIdentifier()] or
     expect_error(dbRemoveTable(con, NA))
-    #' or if this results in a non-scalar.
+    #' if this results in a non-scalar.
     expect_error(dbRemoveTable(con, c(table_name, table_name)))
   },
 

R/spec-sql-unquote-identifier.R

@@ -139,8 +139,8 @@ spec_sql_unquote_identifier <- list(
 
   #'
   unquote_identifier_simple = function(con) {
-    #' Unquoting simple strings (consisting of only letters) wrapped with [SQL()]
-    #' and then quoting via [dbQuoteIdentifier()] gives the same result as just
+    #' Unquoting simple strings (consisting of only letters) wrapped with [SQL()] and
+    #' then quoting via [dbQuoteIdentifier()] gives the same result as just
     #' quoting the string.
     simple_in <- "simple"
     simple_quoted <- dbQuoteIdentifier(con, simple_in)

R/spec-sql-write-table.R

@@ -54,9 +54,9 @@ spec_sql_write_table <- list(
   write_table_error = function(ctx, con, table_name) {
     #' An error is also raised
     test_in <- data.frame(a = 1L)
-    #' if `name` cannot be processed with [dbQuoteIdentifier()]
+    #' if `name` cannot be processed with [dbQuoteIdentifier()] or
     expect_error(dbWriteTable(con, NA, test_in))
-    #' or if this results in a non-scalar.
+    #' if this results in a non-scalar.
     expect_error(dbWriteTable(con, c(table_name, table_name), test_in))
 
     #' Invalid values for the additional arguments `row.names`,